# Generated from solidity-antlr4/Solidity.g4 by ANTLR 4.7.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
from typing.io import TextIO
import sys


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3y")
        buf.write("\u03c5\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\3\2")
        buf.write("\3\2\3\2\7\2\u00ae\n\2\f\2\16\2\u00b1\13\2\3\2\3\2\3\3")
        buf.write("\3\3\3\3\3\3\3\3\3\4\3\4\3\5\3\5\5\5\u00be\n\5\3\6\3\6")
        buf.write("\5\6\u00c2\n\6\3\7\3\7\3\b\5\b\u00c7\n\b\3\b\3\b\3\t\3")
        buf.write("\t\3\t\5\t\u00ce\n\t\3\n\3\n\3\n\3\n\5\n\u00d4\n\n\3\n")
        buf.write("\3\n\3\n\3\n\5\n\u00da\n\n\3\n\3\n\5\n\u00de\n\n\3\n\3")
        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00e8\n\n\f\n\16\n\u00eb")
        buf.write("\13\n\3\n\3\n\3\n\3\n\3\n\5\n\u00f2\n\n\3\13\3\13\3\13")
        buf.write("\3\13\3\13\3\13\7\13\u00fa\n\13\f\13\16\13\u00fd\13\13")
        buf.write("\5\13\u00ff\n\13\3\13\3\13\7\13\u0103\n\13\f\13\16\13")
        buf.write("\u0106\13\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\7\f\u010f\n")
        buf.write("\f\f\f\16\f\u0112\13\f\3\f\3\f\5\f\u0116\n\f\3\r\3\r\3")
        buf.write("\r\3\r\3\r\3\r\3\r\3\r\5\r\u0120\n\r\3\16\3\16\7\16\u0124")
        buf.write("\n\16\f\16\16\16\u0127\13\16\3\16\3\16\3\16\5\16\u012c")
        buf.write("\n\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\5\17\u0135\n")
        buf.write("\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20")
        buf.write("\7\20\u0141\n\20\f\20\16\20\u0144\13\20\5\20\u0146\n\20")
        buf.write("\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\22\5\22")
        buf.write("\u0152\n\22\3\22\3\22\3\23\3\23\3\23\5\23\u0159\n\23\3")
        buf.write("\23\5\23\u015c\n\23\3\24\3\24\5\24\u0160\n\24\3\24\3\24")
        buf.write("\3\24\5\24\u0165\n\24\3\24\3\24\5\24\u0169\n\24\3\25\3")
        buf.write("\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\7\26\u0174\n\26")
        buf.write("\f\26\16\26\u0177\13\26\3\27\3\27\3\27\3\27\5\27\u017d")
        buf.write("\n\27\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3\31\5\31\u0187")
        buf.write("\n\31\3\31\3\31\7\31\u018b\n\31\f\31\16\31\u018e\13\31")
        buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\7\32\u0196\n\32\f\32\16")
        buf.write("\32\u0199\13\32\5\32\u019b\n\32\3\32\3\32\3\33\3\33\5")
        buf.write("\33\u01a1\n\33\3\33\5\33\u01a4\n\33\3\34\3\34\3\34\3\34")
        buf.write("\7\34\u01aa\n\34\f\34\16\34\u01ad\13\34\5\34\u01af\n\34")
        buf.write("\3\34\3\34\3\35\3\35\5\35\u01b5\n\35\3\35\5\35\u01b8\n")
        buf.write("\35\3\36\3\36\3\36\3\36\7\36\u01be\n\36\f\36\16\36\u01c1")
        buf.write("\13\36\5\36\u01c3\n\36\3\36\3\36\3\37\3\37\5\37\u01c9")
        buf.write("\n\37\3 \3 \5 \u01cd\n \3 \3 \3!\3!\3!\3!\3!\3!\3!\5!")
        buf.write("\u01d8\n!\3!\3!\3!\5!\u01dd\n!\3!\7!\u01e0\n!\f!\16!\u01e3")
        buf.write("\13!\3\"\3\"\3\"\7\"\u01e8\n\"\f\"\16\"\u01eb\13\"\3#")
        buf.write("\3#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\7$\u01f9\n$\f$\16$\u01fc")
        buf.write("\13$\3$\3$\5$\u0200\n$\3%\3%\3&\3&\3\'\3\'\7\'\u0208\n")
        buf.write("\'\f\'\16\'\u020b\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3")
        buf.write("(\3(\3(\3(\3(\5(\u021b\n(\3)\3)\3)\3*\3*\3*\3*\3*\3*\3")
        buf.write("*\5*\u0227\n*\3+\3+\3+\3+\3+\3+\3,\3,\5,\u0231\n,\3-\3")
        buf.write("-\3-\3-\5-\u0237\n-\3-\3-\5-\u023b\n-\3-\5-\u023e\n-\3")
        buf.write("-\3-\3-\3.\3.\5.\u0245\n.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3")
        buf.write("/\3\60\3\60\3\60\3\61\3\61\3\61\3\62\3\62\5\62\u0259\n")
        buf.write("\62\3\62\3\62\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\65")
        buf.write("\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u026b\n\65\3\65\3")
        buf.write("\65\5\65\u026f\n\65\3\65\3\65\3\66\5\66\u0274\n\66\3\66")
        buf.write("\3\66\5\66\u0278\n\66\7\66\u027a\n\66\f\66\16\66\u027d")
        buf.write("\13\66\3\67\3\67\5\67\u0281\n\67\3\67\7\67\u0284\n\67")
        buf.write("\f\67\16\67\u0287\13\67\3\67\5\67\u028a\n\67\3\67\3\67")
        buf.write("\38\38\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\3")
        buf.write("9\39\39\59\u02a2\n9\39\39\39\39\39\39\39\39\39\39\39\3")
        buf.write("9\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\3")
        buf.write("9\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\3")
        buf.write("9\39\39\39\39\39\39\39\39\39\79\u02dd\n9\f9\169\u02e0")
        buf.write("\139\3:\3:\3:\3:\3:\3:\3:\5:\u02e9\n:\3:\3:\3:\3:\5:\u02ef")
        buf.write("\n:\5:\u02f1\n:\3;\3;\3;\7;\u02f6\n;\f;\16;\u02f9\13;")
        buf.write("\3<\3<\3<\7<\u02fe\n<\f<\16<\u0301\13<\3<\5<\u0304\n<")
        buf.write("\3=\3=\3=\3=\3>\3>\5>\u030c\n>\3>\3>\5>\u0310\n>\5>\u0312")
        buf.write("\n>\3?\3?\3?\3?\3?\3@\3@\7@\u031b\n@\f@\16@\u031e\13@")
        buf.write("\3@\3@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3")
        buf.write("A\3A\5A\u0333\nA\3B\3B\5B\u0337\nB\3C\3C\3C\3C\5C\u033d")
        buf.write("\nC\3C\3C\5C\u0341\nC\3C\3C\7C\u0345\nC\fC\16C\u0348\13")
        buf.write("C\3C\5C\u034b\nC\3D\3D\3D\3D\5D\u0351\nD\3E\3E\3E\3E\3")
        buf.write("F\3F\3F\3F\3F\5F\u035c\nF\3G\3G\3G\7G\u0361\nG\fG\16G")
        buf.write("\u0364\13G\3H\3H\3H\3I\3I\3I\3J\3J\3J\7J\u036f\nJ\fJ\16")
        buf.write("J\u0372\13J\3K\3K\3K\3K\3K\3K\5K\u037a\nK\3L\3L\3L\3L")
        buf.write("\5L\u0380\nL\3L\3L\5L\u0384\nL\3L\3L\3M\3M\3M\3N\3N\3")
        buf.write("N\5N\u038e\nN\3N\3N\3N\5N\u0393\nN\3N\3N\3O\3O\3O\3O\3")
        buf.write("P\3P\3Q\3Q\3Q\3Q\3R\3R\5R\u03a3\nR\3R\3R\5R\u03a7\nR\7")
        buf.write("R\u03a9\nR\fR\16R\u03ac\13R\3R\3R\3R\3R\3R\7R\u03b3\n")
        buf.write("R\fR\16R\u03b6\13R\5R\u03b8\nR\3R\5R\u03bb\nR\3S\3S\3")
        buf.write("T\3T\5T\u03c1\nT\3U\3U\3U\2\4@pV\2\4\6\b\n\f\16\20\22")
        buf.write("\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPR")
        buf.write("TVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088")
        buf.write("\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a")
        buf.write("\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\2\23\3\2\5")
        buf.write("\13\3\2\23\25\5\2kkooqr\3\2(*\5\2kkppst\5\2$$\63\66]a")
        buf.write("\3\2\678\3\2:;\3\2<=\4\2\16\16@A\3\2BC\3\2\7\n\3\2FG\4")
        buf.write("\2\13\13LU\5\2deggvv\3\2de\5\2\17\17**uu\2\u041e\2\u00af")
        buf.write("\3\2\2\2\4\u00b4\3\2\2\2\6\u00b9\3\2\2\2\b\u00bd\3\2\2")
        buf.write("\2\n\u00bf\3\2\2\2\f\u00c3\3\2\2\2\16\u00c6\3\2\2\2\20")
        buf.write("\u00ca\3\2\2\2\22\u00f1\3\2\2\2\24\u00f3\3\2\2\2\26\u0109")
        buf.write("\3\2\2\2\30\u011f\3\2\2\2\32\u0121\3\2\2\2\34\u012f\3")
        buf.write("\2\2\2\36\u0138\3\2\2\2 \u0149\3\2\2\2\"\u014e\3\2\2\2")
        buf.write("$\u0155\3\2\2\2&\u015d\3\2\2\2(\u016a\3\2\2\2*\u0175\3")
        buf.write("\2\2\2,\u0178\3\2\2\2.\u0180\3\2\2\2\60\u0182\3\2\2\2")
        buf.write("\62\u0191\3\2\2\2\64\u019e\3\2\2\2\66\u01a5\3\2\2\28\u01b2")
        buf.write("\3\2\2\2:\u01b9\3\2\2\2<\u01c6\3\2\2\2>\u01ca\3\2\2\2")
        buf.write("@\u01d7\3\2\2\2B\u01e4\3\2\2\2D\u01ec\3\2\2\2F\u01f3\3")
        buf.write("\2\2\2H\u0201\3\2\2\2J\u0203\3\2\2\2L\u0205\3\2\2\2N\u021a")
        buf.write("\3\2\2\2P\u021c\3\2\2\2R\u021f\3\2\2\2T\u0228\3\2\2\2")
        buf.write("V\u0230\3\2\2\2X\u0232\3\2\2\2Z\u0242\3\2\2\2\\\u0248")
        buf.write("\3\2\2\2^\u0250\3\2\2\2`\u0253\3\2\2\2b\u0256\3\2\2\2")
        buf.write("d\u025c\3\2\2\2f\u025f\3\2\2\2h\u026a\3\2\2\2j\u0273\3")
        buf.write("\2\2\2l\u027e\3\2\2\2n\u028d\3\2\2\2p\u02a1\3\2\2\2r\u02f0")
        buf.write("\3\2\2\2t\u02f2\3\2\2\2v\u02fa\3\2\2\2x\u0305\3\2\2\2")
        buf.write("z\u0311\3\2\2\2|\u0313\3\2\2\2~\u0318\3\2\2\2\u0080\u0332")
        buf.write("\3\2\2\2\u0082\u0336\3\2\2\2\u0084\u033c\3\2\2\2\u0086")
        buf.write("\u034c\3\2\2\2\u0088\u0352\3\2\2\2\u008a\u035b\3\2\2\2")
        buf.write("\u008c\u035d\3\2\2\2\u008e\u0365\3\2\2\2\u0090\u0368\3")
        buf.write("\2\2\2\u0092\u036b\3\2\2\2\u0094\u0379\3\2\2\2\u0096\u037b")
        buf.write("\3\2\2\2\u0098\u0387\3\2\2\2\u009a\u038a\3\2\2\2\u009c")
        buf.write("\u0396\3\2\2\2\u009e\u039a\3\2\2\2\u00a0\u039c\3\2\2\2")
        buf.write("\u00a2\u03ba\3\2\2\2\u00a4\u03bc\3\2\2\2\u00a6\u03be\3")
        buf.write("\2\2\2\u00a8\u03c2\3\2\2\2\u00aa\u00ae\5\4\3\2\u00ab\u00ae")
        buf.write("\5\22\n\2\u00ac\u00ae\5\24\13\2\u00ad\u00aa\3\2\2\2\u00ad")
        buf.write("\u00ab\3\2\2\2\u00ad\u00ac\3\2\2\2\u00ae\u00b1\3\2\2\2")
        buf.write("\u00af\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b2\3")
        buf.write("\2\2\2\u00b1\u00af\3\2\2\2\u00b2\u00b3\7\2\2\3\u00b3\3")
        buf.write("\3\2\2\2\u00b4\u00b5\7\3\2\2\u00b5\u00b6\5\6\4\2\u00b6")
        buf.write("\u00b7\5\b\5\2\u00b7\u00b8\7\4\2\2\u00b8\5\3\2\2\2\u00b9")
        buf.write("\u00ba\5\u00a8U\2\u00ba\7\3\2\2\2\u00bb\u00be\5\n\6\2")
        buf.write("\u00bc\u00be\5p9\2\u00bd\u00bb\3\2\2\2\u00bd\u00bc\3\2")
        buf.write("\2\2\u00be\t\3\2\2\2\u00bf\u00c1\5\16\b\2\u00c0\u00c2")
        buf.write("\5\16\b\2\u00c1\u00c0\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2")
        buf.write("\13\3\2\2\2\u00c3\u00c4\t\2\2\2\u00c4\r\3\2\2\2\u00c5")
        buf.write("\u00c7\5\f\7\2\u00c6\u00c5\3\2\2\2\u00c6\u00c7\3\2\2\2")
        buf.write("\u00c7\u00c8\3\2\2\2\u00c8\u00c9\7b\2\2\u00c9\17\3\2\2")
        buf.write("\2\u00ca\u00cd\5\u00a8U\2\u00cb\u00cc\7\f\2\2\u00cc\u00ce")
        buf.write("\5\u00a8U\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce")
        buf.write("\21\3\2\2\2\u00cf\u00d0\7\r\2\2\u00d0\u00d3\7v\2\2\u00d1")
        buf.write("\u00d2\7\f\2\2\u00d2\u00d4\5\u00a8U\2\u00d3\u00d1\3\2")
        buf.write("\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00f2")
        buf.write("\7\4\2\2\u00d6\u00d9\7\r\2\2\u00d7\u00da\7\16\2\2\u00d8")
        buf.write("\u00da\5\u00a8U\2\u00d9\u00d7\3\2\2\2\u00d9\u00d8\3\2")
        buf.write("\2\2\u00da\u00dd\3\2\2\2\u00db\u00dc\7\f\2\2\u00dc\u00de")
        buf.write("\5\u00a8U\2\u00dd\u00db\3\2\2\2\u00dd\u00de\3\2\2\2\u00de")
        buf.write("\u00df\3\2\2\2\u00df\u00e0\7\17\2\2\u00e0\u00e1\7v\2\2")
        buf.write("\u00e1\u00f2\7\4\2\2\u00e2\u00e3\7\r\2\2\u00e3\u00e4\7")
        buf.write("\20\2\2\u00e4\u00e9\5\20\t\2\u00e5\u00e6\7\21\2\2\u00e6")
        buf.write("\u00e8\5\20\t\2\u00e7\u00e5\3\2\2\2\u00e8\u00eb\3\2\2")
        buf.write("\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00ec")
        buf.write("\3\2\2\2\u00eb\u00e9\3\2\2\2\u00ec\u00ed\7\22\2\2\u00ed")
        buf.write("\u00ee\7\17\2\2\u00ee\u00ef\7v\2\2\u00ef\u00f0\7\4\2\2")
        buf.write("\u00f0\u00f2\3\2\2\2\u00f1\u00cf\3\2\2\2\u00f1\u00d6\3")
        buf.write("\2\2\2\u00f1\u00e2\3\2\2\2\u00f2\23\3\2\2\2\u00f3\u00f4")
        buf.write("\t\3\2\2\u00f4\u00fe\5\u00a8U\2\u00f5\u00f6\7\26\2\2\u00f6")
        buf.write("\u00fb\5\26\f\2\u00f7\u00f8\7\21\2\2\u00f8\u00fa\5\26")
        buf.write("\f\2\u00f9\u00f7\3\2\2\2\u00fa\u00fd\3\2\2\2\u00fb\u00f9")
        buf.write("\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd")
        buf.write("\u00fb\3\2\2\2\u00fe\u00f5\3\2\2\2\u00fe\u00ff\3\2\2\2")
        buf.write("\u00ff\u0100\3\2\2\2\u0100\u0104\7\20\2\2\u0101\u0103")
        buf.write("\5\30\r\2\u0102\u0101\3\2\2\2\u0103\u0106\3\2\2\2\u0104")
        buf.write("\u0102\3\2\2\2\u0104\u0105\3\2\2\2\u0105\u0107\3\2\2\2")
        buf.write("\u0106\u0104\3\2\2\2\u0107\u0108\7\22\2\2\u0108\25\3\2")
        buf.write("\2\2\u0109\u0115\5B\"\2\u010a\u010b\7\27\2\2\u010b\u0110")
        buf.write("\5p9\2\u010c\u010d\7\21\2\2\u010d\u010f\5p9\2\u010e\u010c")
        buf.write("\3\2\2\2\u010f\u0112\3\2\2\2\u0110\u010e\3\2\2\2\u0110")
        buf.write("\u0111\3\2\2\2\u0111\u0113\3\2\2\2\u0112\u0110\3\2\2\2")
        buf.write("\u0113\u0114\7\30\2\2\u0114\u0116\3\2\2\2\u0115\u010a")
        buf.write("\3\2\2\2\u0115\u0116\3\2\2\2\u0116\27\3\2\2\2\u0117\u0120")
        buf.write("\5\32\16\2\u0118\u0120\5\34\17\2\u0119\u0120\5\36\20\2")
        buf.write("\u011a\u0120\5 \21\2\u011b\u0120\5\"\22\2\u011c\u0120")
        buf.write("\5&\24\2\u011d\u0120\5,\27\2\u011e\u0120\5\60\31\2\u011f")
        buf.write("\u0117\3\2\2\2\u011f\u0118\3\2\2\2\u011f\u0119\3\2\2\2")
        buf.write("\u011f\u011a\3\2\2\2\u011f\u011b\3\2\2\2\u011f\u011c\3")
        buf.write("\2\2\2\u011f\u011d\3\2\2\2\u011f\u011e\3\2\2\2\u0120\31")
        buf.write("\3\2\2\2\u0121\u0125\5@!\2\u0122\u0124\t\4\2\2\u0123\u0122")
        buf.write("\3\2\2\2\u0124\u0127\3\2\2\2\u0125\u0123\3\2\2\2\u0125")
        buf.write("\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127\u0125\3\2\2\2")
        buf.write("\u0128\u012b\5\u00a8U\2\u0129\u012a\7\13\2\2\u012a\u012c")
        buf.write("\5p9\2\u012b\u0129\3\2\2\2\u012b\u012c\3\2\2\2\u012c\u012d")
        buf.write("\3\2\2\2\u012d\u012e\7\4\2\2\u012e\33\3\2\2\2\u012f\u0130")
        buf.write("\7\31\2\2\u0130\u0131\5\u00a8U\2\u0131\u0134\7\32\2\2")
        buf.write("\u0132\u0135\7\16\2\2\u0133\u0135\5@!\2\u0134\u0132\3")
        buf.write("\2\2\2\u0134\u0133\3\2\2\2\u0135\u0136\3\2\2\2\u0136\u0137")
        buf.write("\7\4\2\2\u0137\35\3\2\2\2\u0138\u0139\7\33\2\2\u0139\u013a")
        buf.write("\5\u00a8U\2\u013a\u0145\7\20\2\2\u013b\u013c\5> \2\u013c")
        buf.write("\u0142\7\4\2\2\u013d\u013e\5> \2\u013e\u013f\7\4\2\2\u013f")
        buf.write("\u0141\3\2\2\2\u0140\u013d\3\2\2\2\u0141\u0144\3\2\2\2")
        buf.write("\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0146\3")
        buf.write("\2\2\2\u0144\u0142\3\2\2\2\u0145\u013b\3\2\2\2\u0145\u0146")
        buf.write("\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0148\7\22\2\2\u0148")
        buf.write("\37\3\2\2\2\u0149\u014a\7\34\2\2\u014a\u014b\5\62\32\2")
        buf.write("\u014b\u014c\5*\26\2\u014c\u014d\5L\'\2\u014d!\3\2\2\2")
        buf.write("\u014e\u014f\7\35\2\2\u014f\u0151\5\u00a8U\2\u0150\u0152")
        buf.write("\5\62\32\2\u0151\u0150\3\2\2\2\u0151\u0152\3\2\2\2\u0152")
        buf.write("\u0153\3\2\2\2\u0153\u0154\5L\'\2\u0154#\3\2\2\2\u0155")
        buf.write("\u015b\5\u00a8U\2\u0156\u0158\7\27\2\2\u0157\u0159\5t")
        buf.write(";\2\u0158\u0157\3\2\2\2\u0158\u0159\3\2\2\2\u0159\u015a")
        buf.write("\3\2\2\2\u015a\u015c\7\30\2\2\u015b\u0156\3\2\2\2\u015b")
        buf.write("\u015c\3\2\2\2\u015c%\3\2\2\2\u015d\u015f\7\36\2\2\u015e")
        buf.write("\u0160\5\u00a8U\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2")
        buf.write("\2\2\u0160\u0161\3\2\2\2\u0161\u0162\5\62\32\2\u0162\u0164")
        buf.write("\5*\26\2\u0163\u0165\5(\25\2\u0164\u0163\3\2\2\2\u0164")
        buf.write("\u0165\3\2\2\2\u0165\u0168\3\2\2\2\u0166\u0169\7\4\2\2")
        buf.write("\u0167\u0169\5L\'\2\u0168\u0166\3\2\2\2\u0168\u0167\3")
        buf.write("\2\2\2\u0169\'\3\2\2\2\u016a\u016b\7\37\2\2\u016b\u016c")
        buf.write("\5\62\32\2\u016c)\3\2\2\2\u016d\u0174\5$\23\2\u016e\u0174")
        buf.write("\5J&\2\u016f\u0174\7m\2\2\u0170\u0174\7r\2\2\u0171\u0174")
        buf.write("\7o\2\2\u0172\u0174\7q\2\2\u0173\u016d\3\2\2\2\u0173\u016e")
        buf.write("\3\2\2\2\u0173\u016f\3\2\2\2\u0173\u0170\3\2\2\2\u0173")
        buf.write("\u0171\3\2\2\2\u0173\u0172\3\2\2\2\u0174\u0177\3\2\2\2")
        buf.write("\u0175\u0173\3\2\2\2\u0175\u0176\3\2\2\2\u0176+\3\2\2")
        buf.write("\2\u0177\u0175\3\2\2\2\u0178\u0179\7 \2\2\u0179\u017a")
        buf.write("\5\u00a8U\2\u017a\u017c\5\66\34\2\u017b\u017d\7i\2\2\u017c")
        buf.write("\u017b\3\2\2\2\u017c\u017d\3\2\2\2\u017d\u017e\3\2\2\2")
        buf.write("\u017e\u017f\7\4\2\2\u017f-\3\2\2\2\u0180\u0181\5\u00a8")
        buf.write("U\2\u0181/\3\2\2\2\u0182\u0183\7!\2\2\u0183\u0184\5\u00a8")
        buf.write("U\2\u0184\u0186\7\20\2\2\u0185\u0187\5.\30\2\u0186\u0185")
        buf.write("\3\2\2\2\u0186\u0187\3\2\2\2\u0187\u018c\3\2\2\2\u0188")
        buf.write("\u0189\7\21\2\2\u0189\u018b\5.\30\2\u018a\u0188\3\2\2")
        buf.write("\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018c\u018d")
        buf.write("\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f")
        buf.write("\u0190\7\22\2\2\u0190\61\3\2\2\2\u0191\u019a\7\27\2\2")
        buf.write("\u0192\u0197\5\64\33\2\u0193\u0194\7\21\2\2\u0194\u0196")
        buf.write("\5\64\33\2\u0195\u0193\3\2\2\2\u0196\u0199\3\2\2\2\u0197")
        buf.write("\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u019b\3\2\2\2")
        buf.write("\u0199\u0197\3\2\2\2\u019a\u0192\3\2\2\2\u019a\u019b\3")
        buf.write("\2\2\2\u019b\u019c\3\2\2\2\u019c\u019d\7\30\2\2\u019d")
        buf.write("\63\3\2\2\2\u019e\u01a0\5@!\2\u019f\u01a1\5H%\2\u01a0")
        buf.write("\u019f\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1\u01a3\3\2\2\2")
        buf.write("\u01a2\u01a4\5\u00a8U\2\u01a3\u01a2\3\2\2\2\u01a3\u01a4")
        buf.write("\3\2\2\2\u01a4\65\3\2\2\2\u01a5\u01ae\7\27\2\2\u01a6\u01ab")
        buf.write("\58\35\2\u01a7\u01a8\7\21\2\2\u01a8\u01aa\58\35\2\u01a9")
        buf.write("\u01a7\3\2\2\2\u01aa\u01ad\3\2\2\2\u01ab\u01a9\3\2\2\2")
        buf.write("\u01ab\u01ac\3\2\2\2\u01ac\u01af\3\2\2\2\u01ad\u01ab\3")
        buf.write("\2\2\2\u01ae\u01a6\3\2\2\2\u01ae\u01af\3\2\2\2\u01af\u01b0")
        buf.write("\3\2\2\2\u01b0\u01b1\7\30\2\2\u01b1\67\3\2\2\2\u01b2\u01b4")
        buf.write("\5@!\2\u01b3\u01b5\7n\2\2\u01b4\u01b3\3\2\2\2\u01b4\u01b5")
        buf.write("\3\2\2\2\u01b5\u01b7\3\2\2\2\u01b6\u01b8\5\u00a8U\2\u01b7")
        buf.write("\u01b6\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b89\3\2\2\2\u01b9")
        buf.write("\u01c2\7\27\2\2\u01ba\u01bf\5<\37\2\u01bb\u01bc\7\21\2")
        buf.write("\2\u01bc\u01be\5<\37\2\u01bd\u01bb\3\2\2\2\u01be\u01c1")
        buf.write("\3\2\2\2\u01bf\u01bd\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0")
        buf.write("\u01c3\3\2\2\2\u01c1\u01bf\3\2\2\2\u01c2\u01ba\3\2\2\2")
        buf.write("\u01c2\u01c3\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c5\7")
        buf.write("\30\2\2\u01c5;\3\2\2\2\u01c6\u01c8\5@!\2\u01c7\u01c9\5")
        buf.write("H%\2\u01c8\u01c7\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9=\3")
        buf.write("\2\2\2\u01ca\u01cc\5@!\2\u01cb\u01cd\5H%\2\u01cc\u01cb")
        buf.write("\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce")
        buf.write("\u01cf\5\u00a8U\2\u01cf?\3\2\2\2\u01d0\u01d1\b!\1\2\u01d1")
        buf.write("\u01d8\5n8\2\u01d2\u01d8\5B\"\2\u01d3\u01d8\5D#\2\u01d4")
        buf.write("\u01d8\5F$\2\u01d5\u01d6\7$\2\2\u01d6\u01d8\7p\2\2\u01d7")
        buf.write("\u01d0\3\2\2\2\u01d7\u01d2\3\2\2\2\u01d7\u01d3\3\2\2\2")
        buf.write("\u01d7\u01d4\3\2\2\2\u01d7\u01d5\3\2\2\2\u01d8\u01e1\3")
        buf.write("\2\2\2\u01d9\u01da\f\5\2\2\u01da\u01dc\7\"\2\2\u01db\u01dd")
        buf.write("\5p9\2\u01dc\u01db\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01de")
        buf.write("\3\2\2\2\u01de\u01e0\7#\2\2\u01df\u01d9\3\2\2\2\u01e0")
        buf.write("\u01e3\3\2\2\2\u01e1\u01df\3\2\2\2\u01e1\u01e2\3\2\2\2")
        buf.write("\u01e2A\3\2\2\2\u01e3\u01e1\3\2\2\2\u01e4\u01e9\5\u00a8")
        buf.write("U\2\u01e5\u01e6\7%\2\2\u01e6\u01e8\5\u00a8U\2\u01e7\u01e5")
        buf.write("\3\2\2\2\u01e8\u01eb\3\2\2\2\u01e9\u01e7\3\2\2\2\u01e9")
        buf.write("\u01ea\3\2\2\2\u01eaC\3\2\2\2\u01eb\u01e9\3\2\2\2\u01ec")
        buf.write("\u01ed\7&\2\2\u01ed\u01ee\7\27\2\2\u01ee\u01ef\5n8\2\u01ef")
        buf.write("\u01f0\7\'\2\2\u01f0\u01f1\5@!\2\u01f1\u01f2\7\30\2\2")
        buf.write("\u01f2E\3\2\2\2\u01f3\u01f4\7\36\2\2\u01f4\u01fa\5:\36")
        buf.write("\2\u01f5\u01f9\7o\2\2\u01f6\u01f9\7m\2\2\u01f7\u01f9\5")
        buf.write("J&\2\u01f8\u01f5\3\2\2\2\u01f8\u01f6\3\2\2\2\u01f8\u01f7")
        buf.write("\3\2\2\2\u01f9\u01fc\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fa")
        buf.write("\u01fb\3\2\2\2\u01fb\u01ff\3\2\2\2\u01fc\u01fa\3\2\2\2")
        buf.write("\u01fd\u01fe\7\37\2\2\u01fe\u0200\5:\36\2\u01ff\u01fd")
        buf.write("\3\2\2\2\u01ff\u0200\3\2\2\2\u0200G\3\2\2\2\u0201\u0202")
        buf.write("\t\5\2\2\u0202I\3\2\2\2\u0203\u0204\t\6\2\2\u0204K\3\2")
        buf.write("\2\2\u0205\u0209\7\20\2\2\u0206\u0208\5N(\2\u0207\u0206")
        buf.write("\3\2\2\2\u0208\u020b\3\2\2\2\u0209\u0207\3\2\2\2\u0209")
        buf.write("\u020a\3\2\2\2\u020a\u020c\3\2\2\2\u020b\u0209\3\2\2\2")
        buf.write("\u020c\u020d\7\22\2\2\u020dM\3\2\2\2\u020e\u021b\5R*\2")
        buf.write("\u020f\u021b\5T+\2\u0210\u021b\5X-\2\u0211\u021b\5L\'")
        buf.write("\2\u0212\u021b\5Z.\2\u0213\u021b\5\\/\2\u0214\u021b\5")
        buf.write("^\60\2\u0215\u021b\5`\61\2\u0216\u021b\5b\62\2\u0217\u021b")
        buf.write("\5d\63\2\u0218\u021b\5f\64\2\u0219\u021b\5V,\2\u021a\u020e")
        buf.write("\3\2\2\2\u021a\u020f\3\2\2\2\u021a\u0210\3\2\2\2\u021a")
        buf.write("\u0211\3\2\2\2\u021a\u0212\3\2\2\2\u021a\u0213\3\2\2\2")
        buf.write("\u021a\u0214\3\2\2\2\u021a\u0215\3\2\2\2\u021a\u0216\3")
        buf.write("\2\2\2\u021a\u0217\3\2\2\2\u021a\u0218\3\2\2\2\u021a\u0219")
        buf.write("\3\2\2\2\u021bO\3\2\2\2\u021c\u021d\5p9\2\u021d\u021e")
        buf.write("\7\4\2\2\u021eQ\3\2\2\2\u021f\u0220\7+\2\2\u0220\u0221")
        buf.write("\7\27\2\2\u0221\u0222\5p9\2\u0222\u0223\7\30\2\2\u0223")
        buf.write("\u0226\5N(\2\u0224\u0225\7,\2\2\u0225\u0227\5N(\2\u0226")
        buf.write("\u0224\3\2\2\2\u0226\u0227\3\2\2\2\u0227S\3\2\2\2\u0228")
        buf.write("\u0229\7-\2\2\u0229\u022a\7\27\2\2\u022a\u022b\5p9\2\u022b")
        buf.write("\u022c\7\30\2\2\u022c\u022d\5N(\2\u022dU\3\2\2\2\u022e")
        buf.write("\u0231\5h\65\2\u022f\u0231\5P)\2\u0230\u022e\3\2\2\2\u0230")
        buf.write("\u022f\3\2\2\2\u0231W\3\2\2\2\u0232\u0233\7\32\2\2\u0233")
        buf.write("\u0236\7\27\2\2\u0234\u0237\5V,\2\u0235\u0237\7\4\2\2")
        buf.write("\u0236\u0234\3\2\2\2\u0236\u0235\3\2\2\2\u0237\u023a\3")
        buf.write("\2\2\2\u0238\u023b\5P)\2\u0239\u023b\7\4\2\2\u023a\u0238")
        buf.write("\3\2\2\2\u023a\u0239\3\2\2\2\u023b\u023d\3\2\2\2\u023c")
        buf.write("\u023e\5p9\2\u023d\u023c\3\2\2\2\u023d\u023e\3\2\2\2\u023e")
        buf.write("\u023f\3\2\2\2\u023f\u0240\7\30\2\2\u0240\u0241\5N(\2")
        buf.write("\u0241Y\3\2\2\2\u0242\u0244\7.\2\2\u0243\u0245\7v\2\2")
        buf.write("\u0244\u0243\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0246\3")
        buf.write("\2\2\2\u0246\u0247\5~@\2\u0247[\3\2\2\2\u0248\u0249\7")
        buf.write("/\2\2\u0249\u024a\5N(\2\u024a\u024b\7-\2\2\u024b\u024c")
        buf.write("\7\27\2\2\u024c\u024d\5p9\2\u024d\u024e\7\30\2\2\u024e")
        buf.write("\u024f\7\4\2\2\u024f]\3\2\2\2\u0250\u0251\7l\2\2\u0251")
        buf.write("\u0252\7\4\2\2\u0252_\3\2\2\2\u0253\u0254\7j\2\2\u0254")
        buf.write("\u0255\7\4\2\2\u0255a\3\2\2\2\u0256\u0258\7\60\2\2\u0257")
        buf.write("\u0259\5p9\2\u0258\u0257\3\2\2\2\u0258\u0259\3\2\2\2\u0259")
        buf.write("\u025a\3\2\2\2\u025a\u025b\7\4\2\2\u025bc\3\2\2\2\u025c")
        buf.write("\u025d\7\61\2\2\u025d\u025e\7\4\2\2\u025ee\3\2\2\2\u025f")
        buf.write("\u0260\7\62\2\2\u0260\u0261\5|?\2\u0261\u0262\7\4\2\2")
        buf.write("\u0262g\3\2\2\2\u0263\u0264\7\63\2\2\u0264\u026b\5l\67")
        buf.write("\2\u0265\u026b\5> \2\u0266\u0267\7\27\2\2\u0267\u0268")
        buf.write("\5j\66\2\u0268\u0269\7\30\2\2\u0269\u026b\3\2\2\2\u026a")
        buf.write("\u0263\3\2\2\2\u026a\u0265\3\2\2\2\u026a\u0266\3\2\2\2")
        buf.write("\u026b\u026e\3\2\2\2\u026c\u026d\7\13\2\2\u026d\u026f")
        buf.write("\5p9\2\u026e\u026c\3\2\2\2\u026e\u026f\3\2\2\2\u026f\u0270")
        buf.write("\3\2\2\2\u0270\u0271\7\4\2\2\u0271i\3\2\2\2\u0272\u0274")
        buf.write("\5> \2\u0273\u0272\3\2\2\2\u0273\u0274\3\2\2\2\u0274\u027b")
        buf.write("\3\2\2\2\u0275\u0277\7\21\2\2\u0276\u0278\5> \2\u0277")
        buf.write("\u0276\3\2\2\2\u0277\u0278\3\2\2\2\u0278\u027a\3\2\2\2")
        buf.write("\u0279\u0275\3\2\2\2\u027a\u027d\3\2\2\2\u027b\u0279\3")
        buf.write("\2\2\2\u027b\u027c\3\2\2\2\u027ck\3\2\2\2\u027d\u027b")
        buf.write("\3\2\2\2\u027e\u0285\7\27\2\2\u027f\u0281\5\u00a8U\2\u0280")
        buf.write("\u027f\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0282\3\2\2\2")
        buf.write("\u0282\u0284\7\21\2\2\u0283\u0280\3\2\2\2\u0284\u0287")
        buf.write("\3\2\2\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286")
        buf.write("\u0289\3\2\2\2\u0287\u0285\3\2\2\2\u0288\u028a\5\u00a8")
        buf.write("U\2\u0289\u0288\3\2\2\2\u0289\u028a\3\2\2\2\u028a\u028b")
        buf.write("\3\2\2\2\u028b\u028c\7\30\2\2\u028cm\3\2\2\2\u028d\u028e")
        buf.write("\t\7\2\2\u028eo\3\2\2\2\u028f\u0290\b9\1\2\u0290\u0291")
        buf.write("\79\2\2\u0291\u02a2\5@!\2\u0292\u0293\7\27\2\2\u0293\u0294")
        buf.write("\5p9\2\u0294\u0295\7\30\2\2\u0295\u02a2\3\2\2\2\u0296")
        buf.write("\u0297\t\b\2\2\u0297\u02a2\5p9\25\u0298\u0299\t\t\2\2")
        buf.write("\u0299\u02a2\5p9\24\u029a\u029b\t\n\2\2\u029b\u02a2\5")
        buf.write("p9\23\u029c\u029d\7>\2\2\u029d\u02a2\5p9\22\u029e\u029f")
        buf.write("\7\6\2\2\u029f\u02a2\5p9\21\u02a0\u02a2\5r:\2\u02a1\u028f")
        buf.write("\3\2\2\2\u02a1\u0292\3\2\2\2\u02a1\u0296\3\2\2\2\u02a1")
        buf.write("\u0298\3\2\2\2\u02a1\u029a\3\2\2\2\u02a1\u029c\3\2\2\2")
        buf.write("\u02a1\u029e\3\2\2\2\u02a1\u02a0\3\2\2\2\u02a2\u02de\3")
        buf.write("\2\2\2\u02a3\u02a4\f\20\2\2\u02a4\u02a5\7?\2\2\u02a5\u02dd")
        buf.write("\5p9\21\u02a6\u02a7\f\17\2\2\u02a7\u02a8\t\13\2\2\u02a8")
        buf.write("\u02dd\5p9\20\u02a9\u02aa\f\16\2\2\u02aa\u02ab\t\t\2\2")
        buf.write("\u02ab\u02dd\5p9\17\u02ac\u02ad\f\r\2\2\u02ad\u02ae\t")
        buf.write("\f\2\2\u02ae\u02dd\5p9\16\u02af\u02b0\f\f\2\2\u02b0\u02b1")
        buf.write("\7D\2\2\u02b1\u02dd\5p9\r\u02b2\u02b3\f\13\2\2\u02b3\u02b4")
        buf.write("\7\5\2\2\u02b4\u02dd\5p9\f\u02b5\u02b6\f\n\2\2\u02b6\u02b7")
        buf.write("\7E\2\2\u02b7\u02dd\5p9\13\u02b8\u02b9\f\t\2\2\u02b9\u02ba")
        buf.write("\t\r\2\2\u02ba\u02dd\5p9\n\u02bb\u02bc\f\b\2\2\u02bc\u02bd")
        buf.write("\t\16\2\2\u02bd\u02dd\5p9\t\u02be\u02bf\f\7\2\2\u02bf")
        buf.write("\u02c0\7H\2\2\u02c0\u02dd\5p9\b\u02c1\u02c2\f\6\2\2\u02c2")
        buf.write("\u02c3\7I\2\2\u02c3\u02dd\5p9\7\u02c4\u02c5\f\5\2\2\u02c5")
        buf.write("\u02c6\7J\2\2\u02c6\u02c7\5p9\2\u02c7\u02c8\7K\2\2\u02c8")
        buf.write("\u02c9\5p9\6\u02c9\u02dd\3\2\2\2\u02ca\u02cb\f\4\2\2\u02cb")
        buf.write("\u02cc\t\17\2\2\u02cc\u02dd\5p9\5\u02cd\u02ce\f\33\2\2")
        buf.write("\u02ce\u02dd\t\b\2\2\u02cf\u02d0\f\31\2\2\u02d0\u02d1")
        buf.write("\7\"\2\2\u02d1\u02d2\5p9\2\u02d2\u02d3\7#\2\2\u02d3\u02dd")
        buf.write("\3\2\2\2\u02d4\u02d5\f\30\2\2\u02d5\u02d6\7\27\2\2\u02d6")
        buf.write("\u02d7\5z>\2\u02d7\u02d8\7\30\2\2\u02d8\u02dd\3\2\2\2")
        buf.write("\u02d9\u02da\f\27\2\2\u02da\u02db\7%\2\2\u02db\u02dd\5")
        buf.write("\u00a8U\2\u02dc\u02a3\3\2\2\2\u02dc\u02a6\3\2\2\2\u02dc")
        buf.write("\u02a9\3\2\2\2\u02dc\u02ac\3\2\2\2\u02dc\u02af\3\2\2\2")
        buf.write("\u02dc\u02b2\3\2\2\2\u02dc\u02b5\3\2\2\2\u02dc\u02b8\3")
        buf.write("\2\2\2\u02dc\u02bb\3\2\2\2\u02dc\u02be\3\2\2\2\u02dc\u02c1")
        buf.write("\3\2\2\2\u02dc\u02c4\3\2\2\2\u02dc\u02ca\3\2\2\2\u02dc")
        buf.write("\u02cd\3\2\2\2\u02dc\u02cf\3\2\2\2\u02dc\u02d4\3\2\2\2")
        buf.write("\u02dc\u02d9\3\2\2\2\u02dd\u02e0\3\2\2\2\u02de\u02dc\3")
        buf.write("\2\2\2\u02de\u02df\3\2\2\2\u02dfq\3\2\2\2\u02e0\u02de")
        buf.write("\3\2\2\2\u02e1\u02f1\7c\2\2\u02e2\u02f1\5\u00a6T\2\u02e3")
        buf.write("\u02f1\7g\2\2\u02e4\u02f1\7v\2\2\u02e5\u02e8\5\u00a8U")
        buf.write("\2\u02e6\u02e7\7\"\2\2\u02e7\u02e9\7#\2\2\u02e8\u02e6")
        buf.write("\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u02f1\3\2\2\2\u02ea")
        buf.write("\u02f1\5\u00a2R\2\u02eb\u02ee\5\u00a4S\2\u02ec\u02ed\7")
        buf.write("\"\2\2\u02ed\u02ef\7#\2\2\u02ee\u02ec\3\2\2\2\u02ee\u02ef")
        buf.write("\3\2\2\2\u02ef\u02f1\3\2\2\2\u02f0\u02e1\3\2\2\2\u02f0")
        buf.write("\u02e2\3\2\2\2\u02f0\u02e3\3\2\2\2\u02f0\u02e4\3\2\2\2")
        buf.write("\u02f0\u02e5\3\2\2\2\u02f0\u02ea\3\2\2\2\u02f0\u02eb\3")
        buf.write("\2\2\2\u02f1s\3\2\2\2\u02f2\u02f7\5p9\2\u02f3\u02f4\7")
        buf.write("\21\2\2\u02f4\u02f6\5p9\2\u02f5\u02f3\3\2\2\2\u02f6\u02f9")
        buf.write("\3\2\2\2\u02f7\u02f5\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8")
        buf.write("u\3\2\2\2\u02f9\u02f7\3\2\2\2\u02fa\u02ff\5x=\2\u02fb")
        buf.write("\u02fc\7\21\2\2\u02fc\u02fe\5x=\2\u02fd\u02fb\3\2\2\2")
        buf.write("\u02fe\u0301\3\2\2\2\u02ff\u02fd\3\2\2\2\u02ff\u0300\3")
        buf.write("\2\2\2\u0300\u0303\3\2\2\2\u0301\u02ff\3\2\2\2\u0302\u0304")
        buf.write("\7\21\2\2\u0303\u0302\3\2\2\2\u0303\u0304\3\2\2\2\u0304")
        buf.write("w\3\2\2\2\u0305\u0306\5\u00a8U\2\u0306\u0307\7K\2\2\u0307")
        buf.write("\u0308\5p9\2\u0308y\3\2\2\2\u0309\u030b\7\20\2\2\u030a")
        buf.write("\u030c\5v<\2\u030b\u030a\3\2\2\2\u030b\u030c\3\2\2\2\u030c")
        buf.write("\u030d\3\2\2\2\u030d\u0312\7\22\2\2\u030e\u0310\5t;\2")
        buf.write("\u030f\u030e\3\2\2\2\u030f\u0310\3\2\2\2\u0310\u0312\3")
        buf.write("\2\2\2\u0311\u0309\3\2\2\2\u0311\u030f\3\2\2\2\u0312{")
        buf.write("\3\2\2\2\u0313\u0314\5p9\2\u0314\u0315\7\27\2\2\u0315")
        buf.write("\u0316\5z>\2\u0316\u0317\7\30\2\2\u0317}\3\2\2\2\u0318")
        buf.write("\u031c\7\20\2\2\u0319\u031b\5\u0080A\2\u031a\u0319\3\2")
        buf.write("\2\2\u031b\u031e\3\2\2\2\u031c\u031a\3\2\2\2\u031c\u031d")
        buf.write("\3\2\2\2\u031d\u031f\3\2\2\2\u031e\u031c\3\2\2\2\u031f")
        buf.write("\u0320\7\22\2\2\u0320\177\3\2\2\2\u0321\u0333\5\u00a8")
        buf.write("U\2\u0322\u0333\5~@\2\u0323\u0333\5\u0082B\2\u0324\u0333")
        buf.write("\5\u0086D\2\u0325\u0333\5\u0088E\2\u0326\u0333\5\u008e")
        buf.write("H\2\u0327\u0333\5\u0090I\2\u0328\u0333\5\u0092J\2\u0329")
        buf.write("\u0333\5\u0096L\2\u032a\u0333\5\u009aN\2\u032b\u0333\5")
        buf.write("\u009cO\2\u032c\u0333\7j\2\2\u032d\u0333\7l\2\2\u032e")
        buf.write("\u0333\5\u00a0Q\2\u032f\u0333\5\u00a6T\2\u0330\u0333\7")
        buf.write("v\2\2\u0331\u0333\7g\2\2\u0332\u0321\3\2\2\2\u0332\u0322")
        buf.write("\3\2\2\2\u0332\u0323\3\2\2\2\u0332\u0324\3\2\2\2\u0332")
        buf.write("\u0325\3\2\2\2\u0332\u0326\3\2\2\2\u0332\u0327\3\2\2\2")
        buf.write("\u0332\u0328\3\2\2\2\u0332\u0329\3\2\2\2\u0332\u032a\3")
        buf.write("\2\2\2\u0332\u032b\3\2\2\2\u0332\u032c\3\2\2\2\u0332\u032d")
        buf.write("\3\2\2\2\u0332\u032e\3\2\2\2\u0332\u032f\3\2\2\2\u0332")
        buf.write("\u0330\3\2\2\2\u0332\u0331\3\2\2\2\u0333\u0081\3\2\2\2")
        buf.write("\u0334\u0337\5\u0084C\2\u0335\u0337\5\u009eP\2\u0336\u0334")
        buf.write("\3\2\2\2\u0336\u0335\3\2\2\2\u0337\u0083\3\2\2\2\u0338")
        buf.write("\u033d\7\60\2\2\u0339\u033d\7$\2\2\u033a\u033d\7\66\2")
        buf.write("\2\u033b\u033d\5\u00a8U\2\u033c\u0338\3\2\2\2\u033c\u0339")
        buf.write("\3\2\2\2\u033c\u033a\3\2\2\2\u033c\u033b\3\2\2\2\u033d")
        buf.write("\u034a\3\2\2\2\u033e\u0340\7\27\2\2\u033f\u0341\5\u0082")
        buf.write("B\2\u0340\u033f\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0346")
        buf.write("\3\2\2\2\u0342\u0343\7\21\2\2\u0343\u0345\5\u0082B\2\u0344")
        buf.write("\u0342\3\2\2\2\u0345\u0348\3\2\2\2\u0346\u0344\3\2\2\2")
        buf.write("\u0346\u0347\3\2\2\2\u0347\u0349\3\2\2\2\u0348\u0346\3")
        buf.write("\2\2\2\u0349\u034b\7\30\2\2\u034a\u033e\3\2\2\2\u034a")
        buf.write("\u034b\3\2\2\2\u034b\u0085\3\2\2\2\u034c\u034d\7V\2\2")
        buf.write("\u034d\u0350\5\u008aF\2\u034e\u034f\7W\2\2\u034f\u0351")
        buf.write("\5\u0082B\2\u0350\u034e\3\2\2\2\u0350\u0351\3\2\2\2\u0351")
        buf.write("\u0087\3\2\2\2\u0352\u0353\5\u008aF\2\u0353\u0354\7W\2")
        buf.write("\2\u0354\u0355\5\u0082B\2\u0355\u0089\3\2\2\2\u0356\u035c")
        buf.write("\5\u00a8U\2\u0357\u0358\7\27\2\2\u0358\u0359\5\u008cG")
        buf.write("\2\u0359\u035a\7\30\2\2\u035a\u035c\3\2\2\2\u035b\u0356")
        buf.write("\3\2\2\2\u035b\u0357\3\2\2\2\u035c\u008b\3\2\2\2\u035d")
        buf.write("\u0362\5\u00a8U\2\u035e\u035f\7\21\2\2\u035f\u0361\5\u00a8")
        buf.write("U\2\u0360\u035e\3\2\2\2\u0361\u0364\3\2\2\2\u0362\u0360")
        buf.write("\3\2\2\2\u0362\u0363\3\2\2\2\u0363\u008d\3\2\2\2\u0364")
        buf.write("\u0362\3\2\2\2\u0365\u0366\7X\2\2\u0366\u0367\5\u00a8")
        buf.write("U\2\u0367\u008f\3\2\2\2\u0368\u0369\5\u00a8U\2\u0369\u036a")
        buf.write("\7K\2\2\u036a\u0091\3\2\2\2\u036b\u036c\7Y\2\2\u036c\u0370")
        buf.write("\5\u0082B\2\u036d\u036f\5\u0094K\2\u036e\u036d\3\2\2\2")
        buf.write("\u036f\u0372\3\2\2\2\u0370\u036e\3\2\2\2\u0370\u0371\3")
        buf.write("\2\2\2\u0371\u0093\3\2\2\2\u0372\u0370\3\2\2\2\u0373\u0374")
        buf.write("\7Z\2\2\u0374\u0375\5\u009eP\2\u0375\u0376\5~@\2\u0376")
        buf.write("\u037a\3\2\2\2\u0377\u0378\7[\2\2\u0378\u037a\5~@\2\u0379")
        buf.write("\u0373\3\2\2\2\u0379\u0377\3\2\2\2\u037a\u0095\3\2\2\2")
        buf.write("\u037b\u037c\7\36\2\2\u037c\u037d\5\u00a8U\2\u037d\u037f")
        buf.write("\7\27\2\2\u037e\u0380\5\u008cG\2\u037f\u037e\3\2\2\2\u037f")
        buf.write("\u0380\3\2\2\2\u0380\u0381\3\2\2\2\u0381\u0383\7\30\2")
        buf.write("\2\u0382\u0384\5\u0098M\2\u0383\u0382\3\2\2\2\u0383\u0384")
        buf.write("\3\2\2\2\u0384\u0385\3\2\2\2\u0385\u0386\5~@\2\u0386\u0097")
        buf.write("\3\2\2\2\u0387\u0388\7\\\2\2\u0388\u0389\5\u008cG\2\u0389")
        buf.write("\u0099\3\2\2\2\u038a\u038d\7\32\2\2\u038b\u038e\5~@\2")
        buf.write("\u038c\u038e\5\u0082B\2\u038d\u038b\3\2\2\2\u038d\u038c")
        buf.write("\3\2\2\2\u038e\u038f\3\2\2\2\u038f\u0392\5\u0082B\2\u0390")
        buf.write("\u0393\5~@\2\u0391\u0393\5\u0082B\2\u0392\u0390\3\2\2")
        buf.write("\2\u0392\u0391\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0395")
        buf.write("\5~@\2\u0395\u009b\3\2\2\2\u0396\u0397\7+\2\2\u0397\u0398")
        buf.write("\5\u0082B\2\u0398\u0399\5~@\2\u0399\u009d\3\2\2\2\u039a")
        buf.write("\u039b\t\20\2\2\u039b\u009f\3\2\2\2\u039c\u039d\7.\2\2")
        buf.write("\u039d\u039e\5\u00a8U\2\u039e\u039f\5~@\2\u039f\u00a1")
        buf.write("\3\2\2\2\u03a0\u03a2\7\27\2\2\u03a1\u03a3\5p9\2\u03a2")
        buf.write("\u03a1\3\2\2\2\u03a2\u03a3\3\2\2\2\u03a3\u03aa\3\2\2\2")
        buf.write("\u03a4\u03a6\7\21\2\2\u03a5\u03a7\5p9\2\u03a6\u03a5\3")
        buf.write("\2\2\2\u03a6\u03a7\3\2\2\2\u03a7\u03a9\3\2\2\2\u03a8\u03a4")
        buf.write("\3\2\2\2\u03a9\u03ac\3\2\2\2\u03aa\u03a8\3\2\2\2\u03aa")
        buf.write("\u03ab\3\2\2\2\u03ab\u03ad\3\2\2\2\u03ac\u03aa\3\2\2\2")
        buf.write("\u03ad\u03bb\7\30\2\2\u03ae\u03b7\7\"\2\2\u03af\u03b4")
        buf.write("\5p9\2\u03b0\u03b1\7\21\2\2\u03b1\u03b3\5p9\2\u03b2\u03b0")
        buf.write("\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4")
        buf.write("\u03b5\3\2\2\2\u03b5\u03b8\3\2\2\2\u03b6\u03b4\3\2\2\2")
        buf.write("\u03b7\u03af\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3")
        buf.write("\2\2\2\u03b9\u03bb\7#\2\2\u03ba\u03a0\3\2\2\2\u03ba\u03ae")
        buf.write("\3\2\2\2\u03bb\u00a3\3\2\2\2\u03bc\u03bd\5n8\2\u03bd\u00a5")
        buf.write("\3\2\2\2\u03be\u03c0\t\21\2\2\u03bf\u03c1\7f\2\2\u03c0")
        buf.write("\u03bf\3\2\2\2\u03c0\u03c1\3\2\2\2\u03c1\u00a7\3\2\2\2")
        buf.write("\u03c2\u03c3\t\22\2\2\u03c3\u00a9\3\2\2\2j\u00ad\u00af")
        buf.write("\u00bd\u00c1\u00c6\u00cd\u00d3\u00d9\u00dd\u00e9\u00f1")
        buf.write("\u00fb\u00fe\u0104\u0110\u0115\u011f\u0125\u012b\u0134")
        buf.write("\u0142\u0145\u0151\u0158\u015b\u015f\u0164\u0168\u0173")
        buf.write("\u0175\u017c\u0186\u018c\u0197\u019a\u01a0\u01a3\u01ab")
        buf.write("\u01ae\u01b4\u01b7\u01bf\u01c2\u01c8\u01cc\u01d7\u01dc")
        buf.write("\u01e1\u01e9\u01f8\u01fa\u01ff\u0209\u021a\u0226\u0230")
        buf.write("\u0236\u023a\u023d\u0244\u0258\u026a\u026e\u0273\u0277")
        buf.write("\u027b\u0280\u0285\u0289\u02a1\u02dc\u02de\u02e8\u02ee")
        buf.write("\u02f0\u02f7\u02ff\u0303\u030b\u030f\u0311\u031c\u0332")
        buf.write("\u0336\u033c\u0340\u0346\u034a\u0350\u035b\u0362\u0370")
        buf.write("\u0379\u037f\u0383\u038d\u0392\u03a2\u03a6\u03aa\u03b4")
        buf.write("\u03b7\u03ba\u03c0")
        return buf.getvalue()


class SolidityParser ( Parser ):

    grammarFileName = "Solidity.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'pragma'", "';'", "'^'", "'~'", "'>='", 
                     "'>'", "'<'", "'<='", "'='", "'as'", "'import'", "'*'", 
                     "'from'", "'{'", "','", "'}'", "'contract'", "'interface'", 
                     "'library'", "'is'", "'('", "')'", "'using'", "'for'", 
                     "'struct'", "'constructor'", "'modifier'", "'function'", 
                     "'returns'", "'event'", "'enum'", "'['", "']'", "'address'", 
                     "'.'", "'mapping'", "'=>'", "'memory'", "'storage'", 
                     "'calldata'", "'if'", "'else'", "'while'", "'assembly'", 
                     "'do'", "'return'", "'throw'", "'emit'", "'var'", "'bool'", 
                     "'string'", "'byte'", "'++'", "'--'", "'new'", "'+'", 
                     "'-'", "'after'", "'delete'", "'!'", "'**'", "'/'", 
                     "'%'", "'<<'", "'>>'", "'&'", "'|'", "'=='", "'!='", 
                     "'&&'", "'||'", "'?'", "':'", "'|='", "'^='", "'&='", 
                     "'<<='", "'>>='", "'+='", "'-='", "'*='", "'/='", "'%='", 
                     "'let'", "':='", "'=:'", "'switch'", "'case'", "'default'", 
                     "'->'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'anonymous'", "'break'", "'constant'", "'continue'", 
                     "'external'", "'indexed'", "'internal'", "'payable'", 
                     "'private'", "'public'", "'pure'", "'view'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "Int", "Uint", 
                      "Byte", "Fixed", "Ufixed", "VersionLiteral", "BooleanLiteral", 
                      "DecimalNumber", "HexNumber", "NumberUnit", "HexLiteral", 
                      "ReservedKeyword", "AnonymousKeyword", "BreakKeyword", 
                      "ConstantKeyword", "ContinueKeyword", "ExternalKeyword", 
                      "IndexedKeyword", "InternalKeyword", "PayableKeyword", 
                      "PrivateKeyword", "PublicKeyword", "PureKeyword", 
                      "ViewKeyword", "Identifier", "StringLiteral", "WS", 
                      "COMMENT", "LINE_COMMENT" ]

    RULE_sourceUnit = 0
    RULE_pragmaDirective = 1
    RULE_pragmaName = 2
    RULE_pragmaValue = 3
    RULE_version = 4
    RULE_versionOperator = 5
    RULE_versionConstraint = 6
    RULE_importDeclaration = 7
    RULE_importDirective = 8
    RULE_contractDefinition = 9
    RULE_inheritanceSpecifier = 10
    RULE_contractPart = 11
    RULE_stateVariableDeclaration = 12
    RULE_usingForDeclaration = 13
    RULE_structDefinition = 14
    RULE_constructorDefinition = 15
    RULE_modifierDefinition = 16
    RULE_modifierInvocation = 17
    RULE_functionDefinition = 18
    RULE_returnParameters = 19
    RULE_modifierList = 20
    RULE_eventDefinition = 21
    RULE_enumValue = 22
    RULE_enumDefinition = 23
    RULE_parameterList = 24
    RULE_parameter = 25
    RULE_eventParameterList = 26
    RULE_eventParameter = 27
    RULE_functionTypeParameterList = 28
    RULE_functionTypeParameter = 29
    RULE_variableDeclaration = 30
    RULE_typeName = 31
    RULE_userDefinedTypeName = 32
    RULE_mapping = 33
    RULE_functionTypeName = 34
    RULE_storageLocation = 35
    RULE_stateMutability = 36
    RULE_block = 37
    RULE_statement = 38
    RULE_expressionStatement = 39
    RULE_ifStatement = 40
    RULE_whileStatement = 41
    RULE_simpleStatement = 42
    RULE_forStatement = 43
    RULE_inlineAssemblyStatement = 44
    RULE_doWhileStatement = 45
    RULE_continueStatement = 46
    RULE_breakStatement = 47
    RULE_returnStatement = 48
    RULE_throwStatement = 49
    RULE_emitStatement = 50
    RULE_variableDeclarationStatement = 51
    RULE_variableDeclarationList = 52
    RULE_identifierList = 53
    RULE_elementaryTypeName = 54
    RULE_expression = 55
    RULE_primaryExpression = 56
    RULE_expressionList = 57
    RULE_nameValueList = 58
    RULE_nameValue = 59
    RULE_functionCallArguments = 60
    RULE_functionCall = 61
    RULE_assemblyBlock = 62
    RULE_assemblyItem = 63
    RULE_assemblyExpression = 64
    RULE_assemblyCall = 65
    RULE_assemblyLocalDefinition = 66
    RULE_assemblyAssignment = 67
    RULE_assemblyIdentifierOrList = 68
    RULE_assemblyIdentifierList = 69
    RULE_assemblyStackAssignment = 70
    RULE_labelDefinition = 71
    RULE_assemblySwitch = 72
    RULE_assemblyCase = 73
    RULE_assemblyFunctionDefinition = 74
    RULE_assemblyFunctionReturns = 75
    RULE_assemblyFor = 76
    RULE_assemblyIf = 77
    RULE_assemblyLiteral = 78
    RULE_subAssembly = 79
    RULE_tupleExpression = 80
    RULE_elementaryTypeNameExpression = 81
    RULE_numberLiteral = 82
    RULE_identifier = 83

    ruleNames =  [ "sourceUnit", "pragmaDirective", "pragmaName", "pragmaValue", 
                   "version", "versionOperator", "versionConstraint", "importDeclaration", 
                   "importDirective", "contractDefinition", "inheritanceSpecifier", 
                   "contractPart", "stateVariableDeclaration", "usingForDeclaration", 
                   "structDefinition", "constructorDefinition", "modifierDefinition", 
                   "modifierInvocation", "functionDefinition", "returnParameters", 
                   "modifierList", "eventDefinition", "enumValue", "enumDefinition", 
                   "parameterList", "parameter", "eventParameterList", "eventParameter", 
                   "functionTypeParameterList", "functionTypeParameter", 
                   "variableDeclaration", "typeName", "userDefinedTypeName", 
                   "mapping", "functionTypeName", "storageLocation", "stateMutability", 
                   "block", "statement", "expressionStatement", "ifStatement", 
                   "whileStatement", "simpleStatement", "forStatement", 
                   "inlineAssemblyStatement", "doWhileStatement", "continueStatement", 
                   "breakStatement", "returnStatement", "throwStatement", 
                   "emitStatement", "variableDeclarationStatement", "variableDeclarationList", 
                   "identifierList", "elementaryTypeName", "expression", 
                   "primaryExpression", "expressionList", "nameValueList", 
                   "nameValue", "functionCallArguments", "functionCall", 
                   "assemblyBlock", "assemblyItem", "assemblyExpression", 
                   "assemblyCall", "assemblyLocalDefinition", "assemblyAssignment", 
                   "assemblyIdentifierOrList", "assemblyIdentifierList", 
                   "assemblyStackAssignment", "labelDefinition", "assemblySwitch", 
                   "assemblyCase", "assemblyFunctionDefinition", "assemblyFunctionReturns", 
                   "assemblyFor", "assemblyIf", "assemblyLiteral", "subAssembly", 
                   "tupleExpression", "elementaryTypeNameExpression", "numberLiteral", 
                   "identifier" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    T__45=46
    T__46=47
    T__47=48
    T__48=49
    T__49=50
    T__50=51
    T__51=52
    T__52=53
    T__53=54
    T__54=55
    T__55=56
    T__56=57
    T__57=58
    T__58=59
    T__59=60
    T__60=61
    T__61=62
    T__62=63
    T__63=64
    T__64=65
    T__65=66
    T__66=67
    T__67=68
    T__68=69
    T__69=70
    T__70=71
    T__71=72
    T__72=73
    T__73=74
    T__74=75
    T__75=76
    T__76=77
    T__77=78
    T__78=79
    T__79=80
    T__80=81
    T__81=82
    T__82=83
    T__83=84
    T__84=85
    T__85=86
    T__86=87
    T__87=88
    T__88=89
    T__89=90
    Int=91
    Uint=92
    Byte=93
    Fixed=94
    Ufixed=95
    VersionLiteral=96
    BooleanLiteral=97
    DecimalNumber=98
    HexNumber=99
    NumberUnit=100
    HexLiteral=101
    ReservedKeyword=102
    AnonymousKeyword=103
    BreakKeyword=104
    ConstantKeyword=105
    ContinueKeyword=106
    ExternalKeyword=107
    IndexedKeyword=108
    InternalKeyword=109
    PayableKeyword=110
    PrivateKeyword=111
    PublicKeyword=112
    PureKeyword=113
    ViewKeyword=114
    Identifier=115
    StringLiteral=116
    WS=117
    COMMENT=118
    LINE_COMMENT=119

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.7.2")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class SourceUnitContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(SolidityParser.EOF, 0)

        def pragmaDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.PragmaDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.PragmaDirectiveContext,i)


        def importDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDirectiveContext,i)


        def contractDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractDefinitionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_sourceUnit

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSourceUnit" ):
                listener.enterSourceUnit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSourceUnit" ):
                listener.exitSourceUnit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSourceUnit" ):
                return visitor.visitSourceUnit(self)
            else:
                return visitor.visitChildren(self)




    def sourceUnit(self):

        localctx = SolidityParser.SourceUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_sourceUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 173
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__0) | (1 << SolidityParser.T__10) | (1 << SolidityParser.T__16) | (1 << SolidityParser.T__17) | (1 << SolidityParser.T__18))) != 0):
                self.state = 171
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.T__0]:
                    self.state = 168
                    self.pragmaDirective()
                    pass
                elif token in [SolidityParser.T__10]:
                    self.state = 169
                    self.importDirective()
                    pass
                elif token in [SolidityParser.T__16, SolidityParser.T__17, SolidityParser.T__18]:
                    self.state = 170
                    self.contractDefinition()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 175
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 176
            self.match(SolidityParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaDirectiveContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pragmaName(self):
            return self.getTypedRuleContext(SolidityParser.PragmaNameContext,0)


        def pragmaValue(self):
            return self.getTypedRuleContext(SolidityParser.PragmaValueContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaDirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragmaDirective" ):
                listener.enterPragmaDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragmaDirective" ):
                listener.exitPragmaDirective(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaDirective" ):
                return visitor.visitPragmaDirective(self)
            else:
                return visitor.visitChildren(self)




    def pragmaDirective(self):

        localctx = SolidityParser.PragmaDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_pragmaDirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 178
            self.match(SolidityParser.T__0)
            self.state = 179
            self.pragmaName()
            self.state = 180
            self.pragmaValue()
            self.state = 181
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaNameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragmaName" ):
                listener.enterPragmaName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragmaName" ):
                listener.exitPragmaName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaName" ):
                return visitor.visitPragmaName(self)
            else:
                return visitor.visitChildren(self)




    def pragmaName(self):

        localctx = SolidityParser.PragmaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_pragmaName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 183
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaValueContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def version(self):
            return self.getTypedRuleContext(SolidityParser.VersionContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragmaValue" ):
                listener.enterPragmaValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragmaValue" ):
                listener.exitPragmaValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaValue" ):
                return visitor.visitPragmaValue(self)
            else:
                return visitor.visitChildren(self)




    def pragmaValue(self):

        localctx = SolidityParser.PragmaValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_pragmaValue)
        try:
            self.state = 187
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 185
                self.version()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 186
                self.expression(0)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VersionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def versionConstraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VersionConstraintContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VersionConstraintContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_version

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVersion" ):
                listener.enterVersion(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVersion" ):
                listener.exitVersion(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersion" ):
                return visitor.visitVersion(self)
            else:
                return visitor.visitChildren(self)




    def version(self):

        localctx = SolidityParser.VersionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_version)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 189
            self.versionConstraint()
            self.state = 191
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0) or _la==SolidityParser.VersionLiteral:
                self.state = 190
                self.versionConstraint()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VersionOperatorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SolidityParser.RULE_versionOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVersionOperator" ):
                listener.enterVersionOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVersionOperator" ):
                listener.exitVersionOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersionOperator" ):
                return visitor.visitVersionOperator(self)
            else:
                return visitor.visitChildren(self)




    def versionOperator(self):

        localctx = SolidityParser.VersionOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_versionOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 193
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VersionConstraintContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def VersionLiteral(self):
            return self.getToken(SolidityParser.VersionLiteral, 0)

        def versionOperator(self):
            return self.getTypedRuleContext(SolidityParser.VersionOperatorContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_versionConstraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVersionConstraint" ):
                listener.enterVersionConstraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVersionConstraint" ):
                listener.exitVersionConstraint(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersionConstraint" ):
                return visitor.visitVersionConstraint(self)
            else:
                return visitor.visitChildren(self)




    def versionConstraint(self):

        localctx = SolidityParser.VersionConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_versionConstraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 196
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0):
                self.state = 195
                self.versionOperator()


            self.state = 198
            self.match(SolidityParser.VersionLiteral)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImportDeclarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_importDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImportDeclaration" ):
                listener.enterImportDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImportDeclaration" ):
                listener.exitImportDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportDeclaration" ):
                return visitor.visitImportDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def importDeclaration(self):

        localctx = SolidityParser.ImportDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_importDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 200
            self.identifier()
            self.state = 203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__9:
                self.state = 201
                self.match(SolidityParser.T__9)
                self.state = 202
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImportDirectiveContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def importDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_importDirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImportDirective" ):
                listener.enterImportDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImportDirective" ):
                listener.exitImportDirective(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportDirective" ):
                return visitor.visitImportDirective(self)
            else:
                return visitor.visitChildren(self)




    def importDirective(self):

        localctx = SolidityParser.ImportDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_importDirective)
        self._la = 0 # Token type
        try:
            self.state = 239
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 205
                self.match(SolidityParser.T__10)
                self.state = 206
                self.match(SolidityParser.StringLiteral)
                self.state = 209
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__9:
                    self.state = 207
                    self.match(SolidityParser.T__9)
                    self.state = 208
                    self.identifier()


                self.state = 211
                self.match(SolidityParser.T__1)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 212
                self.match(SolidityParser.T__10)
                self.state = 215
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.T__11]:
                    self.state = 213
                    self.match(SolidityParser.T__11)
                    pass
                elif token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.Identifier]:
                    self.state = 214
                    self.identifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 219
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__9:
                    self.state = 217
                    self.match(SolidityParser.T__9)
                    self.state = 218
                    self.identifier()


                self.state = 221
                self.match(SolidityParser.T__12)
                self.state = 222
                self.match(SolidityParser.StringLiteral)
                self.state = 223
                self.match(SolidityParser.T__1)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 224
                self.match(SolidityParser.T__10)
                self.state = 225
                self.match(SolidityParser.T__13)
                self.state = 226
                self.importDeclaration()
                self.state = 231
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 227
                    self.match(SolidityParser.T__14)
                    self.state = 228
                    self.importDeclaration()
                    self.state = 233
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 234
                self.match(SolidityParser.T__15)
                self.state = 235
                self.match(SolidityParser.T__12)
                self.state = 236
                self.match(SolidityParser.StringLiteral)
                self.state = 237
                self.match(SolidityParser.T__1)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContractDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def inheritanceSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.InheritanceSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.InheritanceSpecifierContext,i)


        def contractPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractPartContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractPartContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContractDefinition" ):
                listener.enterContractDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContractDefinition" ):
                listener.exitContractDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContractDefinition" ):
                return visitor.visitContractDefinition(self)
            else:
                return visitor.visitChildren(self)




    def contractDefinition(self):

        localctx = SolidityParser.ContractDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_contractDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 241
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__16) | (1 << SolidityParser.T__17) | (1 << SolidityParser.T__18))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 242
            self.identifier()
            self.state = 252
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__19:
                self.state = 243
                self.match(SolidityParser.T__19)
                self.state = 244
                self.inheritanceSpecifier()
                self.state = 249
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 245
                    self.match(SolidityParser.T__14)
                    self.state = 246
                    self.inheritanceSpecifier()
                    self.state = 251
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 254
            self.match(SolidityParser.T__13)
            self.state = 258
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__22) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__25) | (1 << SolidityParser.T__26) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__30) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                self.state = 255
                self.contractPart()
                self.state = 260
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 261
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InheritanceSpecifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_inheritanceSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInheritanceSpecifier" ):
                listener.enterInheritanceSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInheritanceSpecifier" ):
                listener.exitInheritanceSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInheritanceSpecifier" ):
                return visitor.visitInheritanceSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def inheritanceSpecifier(self):

        localctx = SolidityParser.InheritanceSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_inheritanceSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 263
            self.userDefinedTypeName()
            self.state = 275
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__20:
                self.state = 264
                self.match(SolidityParser.T__20)
                self.state = 265
                self.expression(0)
                self.state = 270
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 266
                    self.match(SolidityParser.T__14)
                    self.state = 267
                    self.expression(0)
                    self.state = 272
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 273
                self.match(SolidityParser.T__21)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContractPartContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def stateVariableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.StateVariableDeclarationContext,0)


        def usingForDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,0)


        def structDefinition(self):
            return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,0)


        def constructorDefinition(self):
            return self.getTypedRuleContext(SolidityParser.ConstructorDefinitionContext,0)


        def modifierDefinition(self):
            return self.getTypedRuleContext(SolidityParser.ModifierDefinitionContext,0)


        def functionDefinition(self):
            return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,0)


        def eventDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EventDefinitionContext,0)


        def enumDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractPart

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContractPart" ):
                listener.enterContractPart(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContractPart" ):
                listener.exitContractPart(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContractPart" ):
                return visitor.visitContractPart(self)
            else:
                return visitor.visitChildren(self)




    def contractPart(self):

        localctx = SolidityParser.ContractPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_contractPart)
        try:
            self.state = 285
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 277
                self.stateVariableDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 278
                self.usingForDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 279
                self.structDefinition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 280
                self.constructorDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 281
                self.modifierDefinition()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 282
                self.functionDefinition()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 283
                self.eventDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 284
                self.enumDefinition()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StateVariableDeclarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def PublicKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PublicKeyword)
            else:
                return self.getToken(SolidityParser.PublicKeyword, i)

        def InternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.InternalKeyword)
            else:
                return self.getToken(SolidityParser.InternalKeyword, i)

        def PrivateKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PrivateKeyword)
            else:
                return self.getToken(SolidityParser.PrivateKeyword, i)

        def ConstantKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.ConstantKeyword)
            else:
                return self.getToken(SolidityParser.ConstantKeyword, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_stateVariableDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStateVariableDeclaration" ):
                listener.enterStateVariableDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStateVariableDeclaration" ):
                listener.exitStateVariableDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStateVariableDeclaration" ):
                return visitor.visitStateVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def stateVariableDeclaration(self):

        localctx = SolidityParser.StateVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_stateVariableDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 287
            self.typeName(0)
            self.state = 291
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 105)) & ~0x3f) == 0 and ((1 << (_la - 105)) & ((1 << (SolidityParser.ConstantKeyword - 105)) | (1 << (SolidityParser.InternalKeyword - 105)) | (1 << (SolidityParser.PrivateKeyword - 105)) | (1 << (SolidityParser.PublicKeyword - 105)))) != 0):
                self.state = 288
                _la = self._input.LA(1)
                if not(((((_la - 105)) & ~0x3f) == 0 and ((1 << (_la - 105)) & ((1 << (SolidityParser.ConstantKeyword - 105)) | (1 << (SolidityParser.InternalKeyword - 105)) | (1 << (SolidityParser.PrivateKeyword - 105)) | (1 << (SolidityParser.PublicKeyword - 105)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 293
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 294
            self.identifier()
            self.state = 297
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__8:
                self.state = 295
                self.match(SolidityParser.T__8)
                self.state = 296
                self.expression(0)


            self.state = 299
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingForDeclarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_usingForDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingForDeclaration" ):
                listener.enterUsingForDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingForDeclaration" ):
                listener.exitUsingForDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingForDeclaration" ):
                return visitor.visitUsingForDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def usingForDeclaration(self):

        localctx = SolidityParser.UsingForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_usingForDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 301
            self.match(SolidityParser.T__22)
            self.state = 302
            self.identifier()
            self.state = 303
            self.match(SolidityParser.T__23)
            self.state = 306
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__11]:
                self.state = 304
                self.match(SolidityParser.T__11)
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__27, SolidityParser.T__33, SolidityParser.T__35, SolidityParser.T__39, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__50, SolidityParser.T__51, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.Identifier]:
                self.state = 305
                self.typeName(0)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 308
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StructDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_structDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStructDefinition" ):
                listener.enterStructDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStructDefinition" ):
                listener.exitStructDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStructDefinition" ):
                return visitor.visitStructDefinition(self)
            else:
                return visitor.visitChildren(self)




    def structDefinition(self):

        localctx = SolidityParser.StructDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_structDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 310
            self.match(SolidityParser.T__24)
            self.state = 311
            self.identifier()
            self.state = 312
            self.match(SolidityParser.T__13)
            self.state = 323
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                self.state = 313
                self.variableDeclaration()
                self.state = 314
                self.match(SolidityParser.T__1)
                self.state = 320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                    self.state = 315
                    self.variableDeclaration()
                    self.state = 316
                    self.match(SolidityParser.T__1)
                    self.state = 322
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 325
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstructorDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def modifierList(self):
            return self.getTypedRuleContext(SolidityParser.ModifierListContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_constructorDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstructorDefinition" ):
                listener.enterConstructorDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstructorDefinition" ):
                listener.exitConstructorDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstructorDefinition" ):
                return visitor.visitConstructorDefinition(self)
            else:
                return visitor.visitChildren(self)




    def constructorDefinition(self):

        localctx = SolidityParser.ConstructorDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_constructorDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.match(SolidityParser.T__25)
            self.state = 328
            self.parameterList()
            self.state = 329
            self.modifierList()
            self.state = 330
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModifierDefinition" ):
                listener.enterModifierDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModifierDefinition" ):
                listener.exitModifierDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierDefinition" ):
                return visitor.visitModifierDefinition(self)
            else:
                return visitor.visitChildren(self)




    def modifierDefinition(self):

        localctx = SolidityParser.ModifierDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_modifierDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 332
            self.match(SolidityParser.T__26)
            self.state = 333
            self.identifier()
            self.state = 335
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__20:
                self.state = 334
                self.parameterList()


            self.state = 337
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierInvocationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierInvocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModifierInvocation" ):
                listener.enterModifierInvocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModifierInvocation" ):
                listener.exitModifierInvocation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierInvocation" ):
                return visitor.visitModifierInvocation(self)
            else:
                return visitor.visitChildren(self)




    def modifierInvocation(self):

        localctx = SolidityParser.ModifierInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_modifierInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self.identifier()
            self.state = 345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__20:
                self.state = 340
                self.match(SolidityParser.T__20)
                self.state = 342
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                    self.state = 341
                    self.expressionList()


                self.state = 344
                self.match(SolidityParser.T__21)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def modifierList(self):
            return self.getTypedRuleContext(SolidityParser.ModifierListContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def returnParameters(self):
            return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionDefinition" ):
                listener.enterFunctionDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionDefinition" ):
                listener.exitFunctionDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionDefinition" ):
                return visitor.visitFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def functionDefinition(self):

        localctx = SolidityParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 347
            self.match(SolidityParser.T__27)
            self.state = 349
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                self.state = 348
                self.identifier()


            self.state = 351
            self.parameterList()
            self.state = 352
            self.modifierList()
            self.state = 354
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__28:
                self.state = 353
                self.returnParameters()


            self.state = 358
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__1]:
                self.state = 356
                self.match(SolidityParser.T__1)
                pass
            elif token in [SolidityParser.T__13]:
                self.state = 357
                self.block()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnParametersContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_returnParameters

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturnParameters" ):
                listener.enterReturnParameters(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturnParameters" ):
                listener.exitReturnParameters(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnParameters" ):
                return visitor.visitReturnParameters(self)
            else:
                return visitor.visitChildren(self)




    def returnParameters(self):

        localctx = SolidityParser.ReturnParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_returnParameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            self.match(SolidityParser.T__28)
            self.state = 361
            self.parameterList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def modifierInvocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ModifierInvocationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ModifierInvocationContext,i)


        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


        def ExternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.ExternalKeyword)
            else:
                return self.getToken(SolidityParser.ExternalKeyword, i)

        def PublicKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PublicKeyword)
            else:
                return self.getToken(SolidityParser.PublicKeyword, i)

        def InternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.InternalKeyword)
            else:
                return self.getToken(SolidityParser.InternalKeyword, i)

        def PrivateKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.PrivateKeyword)
            else:
                return self.getToken(SolidityParser.PrivateKeyword, i)

        def getRuleIndex(self):
            return SolidityParser.RULE_modifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModifierList" ):
                listener.enterModifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModifierList" ):
                listener.exitModifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierList" ):
                return visitor.visitModifierList(self)
            else:
                return visitor.visitChildren(self)




    def modifierList(self):

        localctx = SolidityParser.ModifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_modifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or ((((_la - 105)) & ~0x3f) == 0 and ((1 << (_la - 105)) & ((1 << (SolidityParser.ConstantKeyword - 105)) | (1 << (SolidityParser.ExternalKeyword - 105)) | (1 << (SolidityParser.InternalKeyword - 105)) | (1 << (SolidityParser.PayableKeyword - 105)) | (1 << (SolidityParser.PrivateKeyword - 105)) | (1 << (SolidityParser.PublicKeyword - 105)) | (1 << (SolidityParser.PureKeyword - 105)) | (1 << (SolidityParser.ViewKeyword - 105)) | (1 << (SolidityParser.Identifier - 105)))) != 0):
                self.state = 369
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.Identifier]:
                    self.state = 363
                    self.modifierInvocation()
                    pass
                elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]:
                    self.state = 364
                    self.stateMutability()
                    pass
                elif token in [SolidityParser.ExternalKeyword]:
                    self.state = 365
                    self.match(SolidityParser.ExternalKeyword)
                    pass
                elif token in [SolidityParser.PublicKeyword]:
                    self.state = 366
                    self.match(SolidityParser.PublicKeyword)
                    pass
                elif token in [SolidityParser.InternalKeyword]:
                    self.state = 367
                    self.match(SolidityParser.InternalKeyword)
                    pass
                elif token in [SolidityParser.PrivateKeyword]:
                    self.state = 368
                    self.match(SolidityParser.PrivateKeyword)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 373
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def eventParameterList(self):
            return self.getTypedRuleContext(SolidityParser.EventParameterListContext,0)


        def AnonymousKeyword(self):
            return self.getToken(SolidityParser.AnonymousKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_eventDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEventDefinition" ):
                listener.enterEventDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEventDefinition" ):
                listener.exitEventDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventDefinition" ):
                return visitor.visitEventDefinition(self)
            else:
                return visitor.visitChildren(self)




    def eventDefinition(self):

        localctx = SolidityParser.EventDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_eventDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 374
            self.match(SolidityParser.T__29)
            self.state = 375
            self.identifier()
            self.state = 376
            self.eventParameterList()
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.AnonymousKeyword:
                self.state = 377
                self.match(SolidityParser.AnonymousKeyword)


            self.state = 380
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumValueContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumValue" ):
                listener.enterEnumValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumValue" ):
                listener.exitEnumValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumValue" ):
                return visitor.visitEnumValue(self)
            else:
                return visitor.visitChildren(self)




    def enumValue(self):

        localctx = SolidityParser.EnumValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_enumValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 382
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def enumValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EnumValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EnumValueContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumDefinition" ):
                listener.enterEnumDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumDefinition" ):
                listener.exitEnumDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumDefinition" ):
                return visitor.visitEnumDefinition(self)
            else:
                return visitor.visitChildren(self)




    def enumDefinition(self):

        localctx = SolidityParser.EnumDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_enumDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 384
            self.match(SolidityParser.T__30)
            self.state = 385
            self.identifier()
            self.state = 386
            self.match(SolidityParser.T__13)
            self.state = 388
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                self.state = 387
                self.enumValue()


            self.state = 394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 390
                self.match(SolidityParser.T__14)
                self.state = 391
                self.enumValue()
                self.state = 396
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 397
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_parameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterList" ):
                listener.enterParameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterList" ):
                listener.exitParameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterList" ):
                return visitor.visitParameterList(self)
            else:
                return visitor.visitChildren(self)




    def parameterList(self):

        localctx = SolidityParser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_parameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            self.match(SolidityParser.T__20)
            self.state = 408
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                self.state = 400
                self.parameter()
                self.state = 405
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 401
                    self.match(SolidityParser.T__14)
                    self.state = 402
                    self.parameter()
                    self.state = 407
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 410
            self.match(SolidityParser.T__21)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameter" ):
                listener.enterParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameter" ):
                listener.exitParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameter" ):
                return visitor.visitParameter(self)
            else:
                return visitor.visitChildren(self)




    def parameter(self):

        localctx = SolidityParser.ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 412
            self.typeName(0)
            self.state = 414
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.state = 413
                self.storageLocation()


            self.state = 417
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                self.state = 416
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventParameterListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EventParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EventParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEventParameterList" ):
                listener.enterEventParameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEventParameterList" ):
                listener.exitEventParameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventParameterList" ):
                return visitor.visitEventParameterList(self)
            else:
                return visitor.visitChildren(self)




    def eventParameterList(self):

        localctx = SolidityParser.EventParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_eventParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 419
            self.match(SolidityParser.T__20)
            self.state = 428
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                self.state = 420
                self.eventParameter()
                self.state = 425
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 421
                    self.match(SolidityParser.T__14)
                    self.state = 422
                    self.eventParameter()
                    self.state = 427
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 430
            self.match(SolidityParser.T__21)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventParameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def IndexedKeyword(self):
            return self.getToken(SolidityParser.IndexedKeyword, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEventParameter" ):
                listener.enterEventParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEventParameter" ):
                listener.exitEventParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventParameter" ):
                return visitor.visitEventParameter(self)
            else:
                return visitor.visitChildren(self)




    def eventParameter(self):

        localctx = SolidityParser.EventParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_eventParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 432
            self.typeName(0)
            self.state = 434
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.IndexedKeyword:
                self.state = 433
                self.match(SolidityParser.IndexedKeyword)


            self.state = 437
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                self.state = 436
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeParameterListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def functionTypeParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTypeParameterList" ):
                listener.enterFunctionTypeParameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTypeParameterList" ):
                listener.exitFunctionTypeParameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeParameterList" ):
                return visitor.visitFunctionTypeParameterList(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeParameterList(self):

        localctx = SolidityParser.FunctionTypeParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_functionTypeParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 439
            self.match(SolidityParser.T__20)
            self.state = 448
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                self.state = 440
                self.functionTypeParameter()
                self.state = 445
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 441
                    self.match(SolidityParser.T__14)
                    self.state = 442
                    self.functionTypeParameter()
                    self.state = 447
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 450
            self.match(SolidityParser.T__21)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeParameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTypeParameter" ):
                listener.enterFunctionTypeParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTypeParameter" ):
                listener.exitFunctionTypeParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeParameter" ):
                return visitor.visitFunctionTypeParameter(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeParameter(self):

        localctx = SolidityParser.FunctionTypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_functionTypeParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 452
            self.typeName(0)
            self.state = 454
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__37) | (1 << SolidityParser.T__38) | (1 << SolidityParser.T__39))) != 0):
                self.state = 453
                self.storageLocation()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableDeclaration" ):
                listener.enterVariableDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableDeclaration" ):
                listener.exitVariableDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclaration" ):
                return visitor.visitVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclaration(self):

        localctx = SolidityParser.VariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_variableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 456
            self.typeName(0)
            self.state = 458
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.state = 457
                self.storageLocation()


            self.state = 460
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeNameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def mapping(self):
            return self.getTypedRuleContext(SolidityParser.MappingContext,0)


        def functionTypeName(self):
            return self.getTypedRuleContext(SolidityParser.FunctionTypeNameContext,0)


        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_typeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeName" ):
                listener.enterTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeName" ):
                listener.exitTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeName" ):
                return visitor.visitTypeName(self)
            else:
                return visitor.visitChildren(self)



    def typeName(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.TypeNameContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 62
        self.enterRecursionRule(localctx, 62, self.RULE_typeName, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.state = 463
                self.elementaryTypeName()
                pass

            elif la_ == 2:
                self.state = 464
                self.userDefinedTypeName()
                pass

            elif la_ == 3:
                self.state = 465
                self.mapping()
                pass

            elif la_ == 4:
                self.state = 466
                self.functionTypeName()
                pass

            elif la_ == 5:
                self.state = 467
                self.match(SolidityParser.T__33)
                self.state = 468
                self.match(SolidityParser.PayableKeyword)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 479
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = SolidityParser.TypeNameContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeName)
                    self.state = 471
                    if not self.precpred(self._ctx, 3):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                    self.state = 472
                    self.match(SolidityParser.T__31)
                    self.state = 474
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                        self.state = 473
                        self.expression(0)


                    self.state = 476
                    self.match(SolidityParser.T__32) 
                self.state = 481
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,47,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class UserDefinedTypeNameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_userDefinedTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUserDefinedTypeName" ):
                listener.enterUserDefinedTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUserDefinedTypeName" ):
                listener.exitUserDefinedTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUserDefinedTypeName" ):
                return visitor.visitUserDefinedTypeName(self)
            else:
                return visitor.visitChildren(self)




    def userDefinedTypeName(self):

        localctx = SolidityParser.UserDefinedTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_userDefinedTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 482
            self.identifier()
            self.state = 487
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,48,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 483
                    self.match(SolidityParser.T__34)
                    self.state = 484
                    self.identifier() 
                self.state = 489
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,48,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MappingContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_mapping

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMapping" ):
                listener.enterMapping(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMapping" ):
                listener.exitMapping(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMapping" ):
                return visitor.visitMapping(self)
            else:
                return visitor.visitChildren(self)




    def mapping(self):

        localctx = SolidityParser.MappingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_mapping)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 490
            self.match(SolidityParser.T__35)
            self.state = 491
            self.match(SolidityParser.T__20)
            self.state = 492
            self.elementaryTypeName()
            self.state = 493
            self.match(SolidityParser.T__36)
            self.state = 494
            self.typeName(0)
            self.state = 495
            self.match(SolidityParser.T__21)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeNameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def functionTypeParameterList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterListContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterListContext,i)


        def InternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.InternalKeyword)
            else:
                return self.getToken(SolidityParser.InternalKeyword, i)

        def ExternalKeyword(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.ExternalKeyword)
            else:
                return self.getToken(SolidityParser.ExternalKeyword, i)

        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTypeName" ):
                listener.enterFunctionTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTypeName" ):
                listener.exitFunctionTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeName" ):
                return visitor.visitFunctionTypeName(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeName(self):

        localctx = SolidityParser.FunctionTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_functionTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 497
            self.match(SolidityParser.T__27)
            self.state = 498
            self.functionTypeParameterList()
            self.state = 504
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,50,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 502
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SolidityParser.InternalKeyword]:
                        self.state = 499
                        self.match(SolidityParser.InternalKeyword)
                        pass
                    elif token in [SolidityParser.ExternalKeyword]:
                        self.state = 500
                        self.match(SolidityParser.ExternalKeyword)
                        pass
                    elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]:
                        self.state = 501
                        self.stateMutability()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 506
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,50,self._ctx)

            self.state = 509
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
            if la_ == 1:
                self.state = 507
                self.match(SolidityParser.T__28)
                self.state = 508
                self.functionTypeParameterList()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StorageLocationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SolidityParser.RULE_storageLocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStorageLocation" ):
                listener.enterStorageLocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStorageLocation" ):
                listener.exitStorageLocation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStorageLocation" ):
                return visitor.visitStorageLocation(self)
            else:
                return visitor.visitChildren(self)




    def storageLocation(self):

        localctx = SolidityParser.StorageLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_storageLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 511
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__37) | (1 << SolidityParser.T__38) | (1 << SolidityParser.T__39))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StateMutabilityContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PureKeyword(self):
            return self.getToken(SolidityParser.PureKeyword, 0)

        def ConstantKeyword(self):
            return self.getToken(SolidityParser.ConstantKeyword, 0)

        def ViewKeyword(self):
            return self.getToken(SolidityParser.ViewKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_stateMutability

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStateMutability" ):
                listener.enterStateMutability(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStateMutability" ):
                listener.exitStateMutability(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStateMutability" ):
                return visitor.visitStateMutability(self)
            else:
                return visitor.visitChildren(self)




    def stateMutability(self):

        localctx = SolidityParser.StateMutabilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_stateMutability)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 513
            _la = self._input.LA(1)
            if not(((((_la - 105)) & ~0x3f) == 0 and ((1 << (_la - 105)) & ((1 << (SolidityParser.ConstantKeyword - 105)) | (1 << (SolidityParser.PayableKeyword - 105)) | (1 << (SolidityParser.PureKeyword - 105)) | (1 << (SolidityParser.ViewKeyword - 105)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StatementContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StatementContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_block

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBlock" ):
                listener.enterBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBlock" ):
                listener.exitBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBlock" ):
                return visitor.visitBlock(self)
            else:
                return visitor.visitChildren(self)




    def block(self):

        localctx = SolidityParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 515
            self.match(SolidityParser.T__13)
            self.state = 519
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__13) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__23) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__40) | (1 << SolidityParser.T__42) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__44) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__46) | (1 << SolidityParser.T__47) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.BreakKeyword - 91)) | (1 << (SolidityParser.ContinueKeyword - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                self.state = 516
                self.statement()
                self.state = 521
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 522
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ifStatement(self):
            return self.getTypedRuleContext(SolidityParser.IfStatementContext,0)


        def whileStatement(self):
            return self.getTypedRuleContext(SolidityParser.WhileStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(SolidityParser.ForStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def inlineAssemblyStatement(self):
            return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementContext,0)


        def doWhileStatement(self):
            return self.getTypedRuleContext(SolidityParser.DoWhileStatementContext,0)


        def continueStatement(self):
            return self.getTypedRuleContext(SolidityParser.ContinueStatementContext,0)


        def breakStatement(self):
            return self.getTypedRuleContext(SolidityParser.BreakStatementContext,0)


        def returnStatement(self):
            return self.getTypedRuleContext(SolidityParser.ReturnStatementContext,0)


        def throwStatement(self):
            return self.getTypedRuleContext(SolidityParser.ThrowStatementContext,0)


        def emitStatement(self):
            return self.getTypedRuleContext(SolidityParser.EmitStatementContext,0)


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatement" ):
                listener.enterStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatement" ):
                listener.exitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatement" ):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)




    def statement(self):

        localctx = SolidityParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_statement)
        try:
            self.state = 536
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__40]:
                self.enterOuterAlt(localctx, 1)
                self.state = 524
                self.ifStatement()
                pass
            elif token in [SolidityParser.T__42]:
                self.enterOuterAlt(localctx, 2)
                self.state = 525
                self.whileStatement()
                pass
            elif token in [SolidityParser.T__23]:
                self.enterOuterAlt(localctx, 3)
                self.state = 526
                self.forStatement()
                pass
            elif token in [SolidityParser.T__13]:
                self.enterOuterAlt(localctx, 4)
                self.state = 527
                self.block()
                pass
            elif token in [SolidityParser.T__43]:
                self.enterOuterAlt(localctx, 5)
                self.state = 528
                self.inlineAssemblyStatement()
                pass
            elif token in [SolidityParser.T__44]:
                self.enterOuterAlt(localctx, 6)
                self.state = 529
                self.doWhileStatement()
                pass
            elif token in [SolidityParser.ContinueKeyword]:
                self.enterOuterAlt(localctx, 7)
                self.state = 530
                self.continueStatement()
                pass
            elif token in [SolidityParser.BreakKeyword]:
                self.enterOuterAlt(localctx, 8)
                self.state = 531
                self.breakStatement()
                pass
            elif token in [SolidityParser.T__45]:
                self.enterOuterAlt(localctx, 9)
                self.state = 532
                self.returnStatement()
                pass
            elif token in [SolidityParser.T__46]:
                self.enterOuterAlt(localctx, 10)
                self.state = 533
                self.throwStatement()
                pass
            elif token in [SolidityParser.T__47]:
                self.enterOuterAlt(localctx, 11)
                self.state = 534
                self.emitStatement()
                pass
            elif token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__20, SolidityParser.T__27, SolidityParser.T__31, SolidityParser.T__33, SolidityParser.T__35, SolidityParser.T__39, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__50, SolidityParser.T__51, SolidityParser.T__52, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.enterOuterAlt(localctx, 12)
                self.state = 535
                self.simpleStatement()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expressionStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionStatement" ):
                listener.enterExpressionStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionStatement" ):
                listener.exitExpressionStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionStatement" ):
                return visitor.visitExpressionStatement(self)
            else:
                return visitor.visitChildren(self)




    def expressionStatement(self):

        localctx = SolidityParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_expressionStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self.expression(0)
            self.state = 539
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StatementContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StatementContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_ifStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIfStatement" ):
                listener.enterIfStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIfStatement" ):
                listener.exitIfStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfStatement" ):
                return visitor.visitIfStatement(self)
            else:
                return visitor.visitChildren(self)




    def ifStatement(self):

        localctx = SolidityParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_ifStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 541
            self.match(SolidityParser.T__40)
            self.state = 542
            self.match(SolidityParser.T__20)
            self.state = 543
            self.expression(0)
            self.state = 544
            self.match(SolidityParser.T__21)
            self.state = 545
            self.statement()
            self.state = 548
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.state = 546
                self.match(SolidityParser.T__41)
                self.state = 547
                self.statement()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhileStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_whileStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWhileStatement" ):
                listener.enterWhileStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWhileStatement" ):
                listener.exitWhileStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhileStatement" ):
                return visitor.visitWhileStatement(self)
            else:
                return visitor.visitChildren(self)




    def whileStatement(self):

        localctx = SolidityParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 550
            self.match(SolidityParser.T__42)
            self.state = 551
            self.match(SolidityParser.T__20)
            self.state = 552
            self.expression(0)
            self.state = 553
            self.match(SolidityParser.T__21)
            self.state = 554
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableDeclarationStatement(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_simpleStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleStatement" ):
                listener.enterSimpleStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleStatement" ):
                listener.exitSimpleStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleStatement" ):
                return visitor.visitSimpleStatement(self)
            else:
                return visitor.visitChildren(self)




    def simpleStatement(self):

        localctx = SolidityParser.SimpleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_simpleStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 558
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 556
                self.variableDeclarationStatement()
                pass

            elif la_ == 2:
                self.state = 557
                self.expressionStatement()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_forStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForStatement" ):
                listener.enterForStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForStatement" ):
                listener.exitForStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForStatement" ):
                return visitor.visitForStatement(self)
            else:
                return visitor.visitChildren(self)




    def forStatement(self):

        localctx = SolidityParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 560
            self.match(SolidityParser.T__23)
            self.state = 561
            self.match(SolidityParser.T__20)
            self.state = 564
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__20, SolidityParser.T__27, SolidityParser.T__31, SolidityParser.T__33, SolidityParser.T__35, SolidityParser.T__39, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__50, SolidityParser.T__51, SolidityParser.T__52, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 562
                self.simpleStatement()
                pass
            elif token in [SolidityParser.T__1]:
                self.state = 563
                self.match(SolidityParser.T__1)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 568
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__20, SolidityParser.T__31, SolidityParser.T__33, SolidityParser.T__39, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__50, SolidityParser.T__51, SolidityParser.T__52, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 566
                self.expressionStatement()
                pass
            elif token in [SolidityParser.T__1]:
                self.state = 567
                self.match(SolidityParser.T__1)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 571
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                self.state = 570
                self.expression(0)


            self.state = 573
            self.match(SolidityParser.T__21)
            self.state = 574
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InlineAssemblyStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_inlineAssemblyStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInlineAssemblyStatement" ):
                listener.enterInlineAssemblyStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInlineAssemblyStatement" ):
                listener.exitInlineAssemblyStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineAssemblyStatement" ):
                return visitor.visitInlineAssemblyStatement(self)
            else:
                return visitor.visitChildren(self)




    def inlineAssemblyStatement(self):

        localctx = SolidityParser.InlineAssemblyStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_inlineAssemblyStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.match(SolidityParser.T__43)
            self.state = 578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.StringLiteral:
                self.state = 577
                self.match(SolidityParser.StringLiteral)


            self.state = 580
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DoWhileStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_doWhileStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDoWhileStatement" ):
                listener.enterDoWhileStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDoWhileStatement" ):
                listener.exitDoWhileStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDoWhileStatement" ):
                return visitor.visitDoWhileStatement(self)
            else:
                return visitor.visitChildren(self)




    def doWhileStatement(self):

        localctx = SolidityParser.DoWhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_doWhileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 582
            self.match(SolidityParser.T__44)
            self.state = 583
            self.statement()
            self.state = 584
            self.match(SolidityParser.T__42)
            self.state = 585
            self.match(SolidityParser.T__20)
            self.state = 586
            self.expression(0)
            self.state = 587
            self.match(SolidityParser.T__21)
            self.state = 588
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContinueStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_continueStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContinueStatement" ):
                listener.enterContinueStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContinueStatement" ):
                listener.exitContinueStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContinueStatement" ):
                return visitor.visitContinueStatement(self)
            else:
                return visitor.visitChildren(self)




    def continueStatement(self):

        localctx = SolidityParser.ContinueStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_continueStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 590
            self.match(SolidityParser.ContinueKeyword)
            self.state = 591
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BreakStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_breakStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBreakStatement" ):
                listener.enterBreakStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBreakStatement" ):
                listener.exitBreakStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBreakStatement" ):
                return visitor.visitBreakStatement(self)
            else:
                return visitor.visitChildren(self)




    def breakStatement(self):

        localctx = SolidityParser.BreakStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_breakStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 593
            self.match(SolidityParser.BreakKeyword)
            self.state = 594
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_returnStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturnStatement" ):
                listener.enterReturnStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturnStatement" ):
                listener.exitReturnStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnStatement" ):
                return visitor.visitReturnStatement(self)
            else:
                return visitor.visitChildren(self)




    def returnStatement(self):

        localctx = SolidityParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_returnStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 596
            self.match(SolidityParser.T__45)
            self.state = 598
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                self.state = 597
                self.expression(0)


            self.state = 600
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ThrowStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SolidityParser.RULE_throwStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterThrowStatement" ):
                listener.enterThrowStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitThrowStatement" ):
                listener.exitThrowStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitThrowStatement" ):
                return visitor.visitThrowStatement(self)
            else:
                return visitor.visitChildren(self)




    def throwStatement(self):

        localctx = SolidityParser.ThrowStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_throwStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 602
            self.match(SolidityParser.T__46)
            self.state = 603
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EmitStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def functionCall(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_emitStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEmitStatement" ):
                listener.enterEmitStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEmitStatement" ):
                listener.exitEmitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEmitStatement" ):
                return visitor.visitEmitStatement(self)
            else:
                return visitor.visitChildren(self)




    def emitStatement(self):

        localctx = SolidityParser.EmitStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_emitStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 605
            self.match(SolidityParser.T__47)
            self.state = 606
            self.functionCall()
            self.state = 607
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifierList(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierListContext,0)


        def variableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,0)


        def variableDeclarationList(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationListContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableDeclarationStatement" ):
                listener.enterVariableDeclarationStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableDeclarationStatement" ):
                listener.exitVariableDeclarationStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclarationStatement" ):
                return visitor.visitVariableDeclarationStatement(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclarationStatement(self):

        localctx = SolidityParser.VariableDeclarationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_variableDeclarationStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 616
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
            if la_ == 1:
                self.state = 609
                self.match(SolidityParser.T__48)
                self.state = 610
                self.identifierList()
                pass

            elif la_ == 2:
                self.state = 611
                self.variableDeclaration()
                pass

            elif la_ == 3:
                self.state = 612
                self.match(SolidityParser.T__20)
                self.state = 613
                self.variableDeclarationList()
                self.state = 614
                self.match(SolidityParser.T__21)
                pass


            self.state = 620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__8:
                self.state = 618
                self.match(SolidityParser.T__8)
                self.state = 619
                self.expression(0)


            self.state = 622
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableDeclarationList" ):
                listener.enterVariableDeclarationList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableDeclarationList" ):
                listener.exitVariableDeclarationList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclarationList" ):
                return visitor.visitVariableDeclarationList(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclarationList(self):

        localctx = SolidityParser.VariableDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_variableDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 625
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                self.state = 624
                self.variableDeclaration()


            self.state = 633
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 627
                self.match(SolidityParser.T__14)
                self.state = 629
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.Identifier - 91)))) != 0):
                    self.state = 628
                    self.variableDeclaration()


                self.state = 635
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_identifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdentifierList" ):
                listener.enterIdentifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdentifierList" ):
                listener.exitIdentifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierList" ):
                return visitor.visitIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def identifierList(self):

        localctx = SolidityParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 636
            self.match(SolidityParser.T__20)
            self.state = 643
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,67,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 638
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                        self.state = 637
                        self.identifier()


                    self.state = 640
                    self.match(SolidityParser.T__14) 
                self.state = 645
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,67,self._ctx)

            self.state = 647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                self.state = 646
                self.identifier()


            self.state = 649
            self.match(SolidityParser.T__21)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElementaryTypeNameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Int(self):
            return self.getToken(SolidityParser.Int, 0)

        def Uint(self):
            return self.getToken(SolidityParser.Uint, 0)

        def Byte(self):
            return self.getToken(SolidityParser.Byte, 0)

        def Fixed(self):
            return self.getToken(SolidityParser.Fixed, 0)

        def Ufixed(self):
            return self.getToken(SolidityParser.Ufixed, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_elementaryTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElementaryTypeName" ):
                listener.enterElementaryTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElementaryTypeName" ):
                listener.exitElementaryTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElementaryTypeName" ):
                return visitor.visitElementaryTypeName(self)
            else:
                return visitor.visitChildren(self)




    def elementaryTypeName(self):

        localctx = SolidityParser.ElementaryTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_elementaryTypeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 651
            _la = self._input.LA(1)
            if not(((((_la - 34)) & ~0x3f) == 0 and ((1 << (_la - 34)) & ((1 << (SolidityParser.T__33 - 34)) | (1 << (SolidityParser.T__48 - 34)) | (1 << (SolidityParser.T__49 - 34)) | (1 << (SolidityParser.T__50 - 34)) | (1 << (SolidityParser.T__51 - 34)) | (1 << (SolidityParser.Int - 34)) | (1 << (SolidityParser.Uint - 34)) | (1 << (SolidityParser.Byte - 34)) | (1 << (SolidityParser.Fixed - 34)) | (1 << (SolidityParser.Ufixed - 34)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def primaryExpression(self):
            return self.getTypedRuleContext(SolidityParser.PrimaryExpressionContext,0)


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpression" ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpression" ):
                listener.exitExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 110
        self.enterRecursionRule(localctx, 110, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 671
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 654
                self.match(SolidityParser.T__54)
                self.state = 655
                self.typeName(0)
                pass

            elif la_ == 2:
                self.state = 656
                self.match(SolidityParser.T__20)
                self.state = 657
                self.expression(0)
                self.state = 658
                self.match(SolidityParser.T__21)
                pass

            elif la_ == 3:
                self.state = 660
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__52 or _la==SolidityParser.T__53):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 661
                self.expression(19)
                pass

            elif la_ == 4:
                self.state = 662
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__55 or _la==SolidityParser.T__56):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 663
                self.expression(18)
                pass

            elif la_ == 5:
                self.state = 664
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__57 or _la==SolidityParser.T__58):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 665
                self.expression(17)
                pass

            elif la_ == 6:
                self.state = 666
                self.match(SolidityParser.T__59)
                self.state = 667
                self.expression(16)
                pass

            elif la_ == 7:
                self.state = 668
                self.match(SolidityParser.T__3)
                self.state = 669
                self.expression(15)
                pass

            elif la_ == 8:
                self.state = 670
                self.primaryExpression()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 732
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,71,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 730
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
                    if la_ == 1:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 673
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 674
                        self.match(SolidityParser.T__60)
                        self.state = 675
                        self.expression(15)
                        pass

                    elif la_ == 2:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 676
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 677
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__11) | (1 << SolidityParser.T__61) | (1 << SolidityParser.T__62))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 678
                        self.expression(14)
                        pass

                    elif la_ == 3:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 679
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 680
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__55 or _la==SolidityParser.T__56):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 681
                        self.expression(13)
                        pass

                    elif la_ == 4:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 682
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 683
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__63 or _la==SolidityParser.T__64):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 684
                        self.expression(12)
                        pass

                    elif la_ == 5:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 685
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 686
                        self.match(SolidityParser.T__65)
                        self.state = 687
                        self.expression(11)
                        pass

                    elif la_ == 6:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 688
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 689
                        self.match(SolidityParser.T__2)
                        self.state = 690
                        self.expression(10)
                        pass

                    elif la_ == 7:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 691
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 692
                        self.match(SolidityParser.T__66)
                        self.state = 693
                        self.expression(9)
                        pass

                    elif la_ == 8:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 694
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 695
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 696
                        self.expression(8)
                        pass

                    elif la_ == 9:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 697
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 698
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__67 or _la==SolidityParser.T__68):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 699
                        self.expression(7)
                        pass

                    elif la_ == 10:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 700
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 701
                        self.match(SolidityParser.T__69)
                        self.state = 702
                        self.expression(6)
                        pass

                    elif la_ == 11:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 703
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 704
                        self.match(SolidityParser.T__70)
                        self.state = 705
                        self.expression(5)
                        pass

                    elif la_ == 12:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 706
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 707
                        self.match(SolidityParser.T__71)
                        self.state = 708
                        self.expression(0)
                        self.state = 709
                        self.match(SolidityParser.T__72)
                        self.state = 710
                        self.expression(4)
                        pass

                    elif la_ == 13:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 712
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 713
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__8 or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & ((1 << (SolidityParser.T__73 - 74)) | (1 << (SolidityParser.T__74 - 74)) | (1 << (SolidityParser.T__75 - 74)) | (1 << (SolidityParser.T__76 - 74)) | (1 << (SolidityParser.T__77 - 74)) | (1 << (SolidityParser.T__78 - 74)) | (1 << (SolidityParser.T__79 - 74)) | (1 << (SolidityParser.T__80 - 74)) | (1 << (SolidityParser.T__81 - 74)) | (1 << (SolidityParser.T__82 - 74)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 714
                        self.expression(3)
                        pass

                    elif la_ == 14:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 715
                        if not self.precpred(self._ctx, 25):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 25)")
                        self.state = 716
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__52 or _la==SolidityParser.T__53):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass

                    elif la_ == 15:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 717
                        if not self.precpred(self._ctx, 23):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 23)")
                        self.state = 718
                        self.match(SolidityParser.T__31)
                        self.state = 719
                        self.expression(0)
                        self.state = 720
                        self.match(SolidityParser.T__32)
                        pass

                    elif la_ == 16:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 722
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 723
                        self.match(SolidityParser.T__20)
                        self.state = 724
                        self.functionCallArguments()
                        self.state = 725
                        self.match(SolidityParser.T__21)
                        pass

                    elif la_ == 17:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 727
                        if not self.precpred(self._ctx, 21):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
                        self.state = 728
                        self.match(SolidityParser.T__34)
                        self.state = 729
                        self.identifier()
                        pass

             
                self.state = 734
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,71,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class PrimaryExpressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BooleanLiteral(self):
            return self.getToken(SolidityParser.BooleanLiteral, 0)

        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def HexLiteral(self):
            return self.getToken(SolidityParser.HexLiteral, 0)

        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def tupleExpression(self):
            return self.getTypedRuleContext(SolidityParser.TupleExpressionContext,0)


        def elementaryTypeNameExpression(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_primaryExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrimaryExpression" ):
                listener.enterPrimaryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrimaryExpression" ):
                listener.exitPrimaryExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimaryExpression" ):
                return visitor.visitPrimaryExpression(self)
            else:
                return visitor.visitChildren(self)




    def primaryExpression(self):

        localctx = SolidityParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_primaryExpression)
        try:
            self.state = 750
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.BooleanLiteral]:
                self.enterOuterAlt(localctx, 1)
                self.state = 735
                self.match(SolidityParser.BooleanLiteral)
                pass
            elif token in [SolidityParser.DecimalNumber, SolidityParser.HexNumber]:
                self.enterOuterAlt(localctx, 2)
                self.state = 736
                self.numberLiteral()
                pass
            elif token in [SolidityParser.HexLiteral]:
                self.enterOuterAlt(localctx, 3)
                self.state = 737
                self.match(SolidityParser.HexLiteral)
                pass
            elif token in [SolidityParser.StringLiteral]:
                self.enterOuterAlt(localctx, 4)
                self.state = 738
                self.match(SolidityParser.StringLiteral)
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 5)
                self.state = 739
                self.identifier()
                self.state = 742
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
                if la_ == 1:
                    self.state = 740
                    self.match(SolidityParser.T__31)
                    self.state = 741
                    self.match(SolidityParser.T__32)


                pass
            elif token in [SolidityParser.T__20, SolidityParser.T__31]:
                self.enterOuterAlt(localctx, 6)
                self.state = 744
                self.tupleExpression()
                pass
            elif token in [SolidityParser.T__33, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__50, SolidityParser.T__51, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed]:
                self.enterOuterAlt(localctx, 7)
                self.state = 745
                self.elementaryTypeNameExpression()
                self.state = 748
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                if la_ == 1:
                    self.state = 746
                    self.match(SolidityParser.T__31)
                    self.state = 747
                    self.match(SolidityParser.T__32)


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_expressionList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionList" ):
                listener.enterExpressionList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionList" ):
                listener.exitExpressionList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionList" ):
                return visitor.visitExpressionList(self)
            else:
                return visitor.visitChildren(self)




    def expressionList(self):

        localctx = SolidityParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 752
            self.expression(0)
            self.state = 757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 753
                self.match(SolidityParser.T__14)
                self.state = 754
                self.expression(0)
                self.state = 759
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameValueListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nameValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.NameValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.NameValueContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_nameValueList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNameValueList" ):
                listener.enterNameValueList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNameValueList" ):
                listener.exitNameValueList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNameValueList" ):
                return visitor.visitNameValueList(self)
            else:
                return visitor.visitChildren(self)




    def nameValueList(self):

        localctx = SolidityParser.NameValueListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_nameValueList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 760
            self.nameValue()
            self.state = 765
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 761
                    self.match(SolidityParser.T__14)
                    self.state = 762
                    self.nameValue() 
                self.state = 767
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,76,self._ctx)

            self.state = 769
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__14:
                self.state = 768
                self.match(SolidityParser.T__14)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameValueContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_nameValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNameValue" ):
                listener.enterNameValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNameValue" ):
                listener.exitNameValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNameValue" ):
                return visitor.visitNameValue(self)
            else:
                return visitor.visitChildren(self)




    def nameValue(self):

        localctx = SolidityParser.NameValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_nameValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 771
            self.identifier()
            self.state = 772
            self.match(SolidityParser.T__72)
            self.state = 773
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallArgumentsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nameValueList(self):
            return self.getTypedRuleContext(SolidityParser.NameValueListContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionCallArguments

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionCallArguments" ):
                listener.enterFunctionCallArguments(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionCallArguments" ):
                listener.exitFunctionCallArguments(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCallArguments" ):
                return visitor.visitFunctionCallArguments(self)
            else:
                return visitor.visitChildren(self)




    def functionCallArguments(self):

        localctx = SolidityParser.FunctionCallArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_functionCallArguments)
        self._la = 0 # Token type
        try:
            self.state = 783
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__13]:
                self.enterOuterAlt(localctx, 1)
                self.state = 775
                self.match(SolidityParser.T__13)
                self.state = 777
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                    self.state = 776
                    self.nameValueList()


                self.state = 779
                self.match(SolidityParser.T__15)
                pass
            elif token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__20, SolidityParser.T__21, SolidityParser.T__31, SolidityParser.T__33, SolidityParser.T__39, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__50, SolidityParser.T__51, SolidityParser.T__52, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 781
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                    self.state = 780
                    self.expressionList()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionCall" ):
                listener.enterFunctionCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionCall" ):
                listener.exitFunctionCall(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCall" ):
                return visitor.visitFunctionCall(self)
            else:
                return visitor.visitChildren(self)




    def functionCall(self):

        localctx = SolidityParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_functionCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 785
            self.expression(0)
            self.state = 786
            self.match(SolidityParser.T__20)
            self.state = 787
            self.functionCallArguments()
            self.state = 788
            self.match(SolidityParser.T__21)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyBlockContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyItemContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyItemContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyBlock" ):
                listener.enterAssemblyBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyBlock" ):
                listener.exitAssemblyBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyBlock" ):
                return visitor.visitAssemblyBlock(self)
            else:
                return visitor.visitChildren(self)




    def assemblyBlock(self):

        localctx = SolidityParser.AssemblyBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_assemblyBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 790
            self.match(SolidityParser.T__13)
            self.state = 794
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__13) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__23) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__40) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (SolidityParser.T__83 - 84)) | (1 << (SolidityParser.T__85 - 84)) | (1 << (SolidityParser.T__86 - 84)) | (1 << (SolidityParser.DecimalNumber - 84)) | (1 << (SolidityParser.HexNumber - 84)) | (1 << (SolidityParser.HexLiteral - 84)) | (1 << (SolidityParser.BreakKeyword - 84)) | (1 << (SolidityParser.ContinueKeyword - 84)) | (1 << (SolidityParser.Identifier - 84)) | (1 << (SolidityParser.StringLiteral - 84)))) != 0):
                self.state = 791
                self.assemblyItem()
                self.state = 796
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 797
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyItemContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyLocalDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLocalDefinitionContext,0)


        def assemblyAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyAssignmentContext,0)


        def assemblyStackAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyStackAssignmentContext,0)


        def labelDefinition(self):
            return self.getTypedRuleContext(SolidityParser.LabelDefinitionContext,0)


        def assemblySwitch(self):
            return self.getTypedRuleContext(SolidityParser.AssemblySwitchContext,0)


        def assemblyFunctionDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionDefinitionContext,0)


        def assemblyFor(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyForContext,0)


        def assemblyIf(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIfContext,0)


        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def subAssembly(self):
            return self.getTypedRuleContext(SolidityParser.SubAssemblyContext,0)


        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def HexLiteral(self):
            return self.getToken(SolidityParser.HexLiteral, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyItem" ):
                listener.enterAssemblyItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyItem" ):
                listener.exitAssemblyItem(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyItem" ):
                return visitor.visitAssemblyItem(self)
            else:
                return visitor.visitChildren(self)




    def assemblyItem(self):

        localctx = SolidityParser.AssemblyItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_assemblyItem)
        try:
            self.state = 816
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 799
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 800
                self.assemblyBlock()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 801
                self.assemblyExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 802
                self.assemblyLocalDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 803
                self.assemblyAssignment()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 804
                self.assemblyStackAssignment()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 805
                self.labelDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 806
                self.assemblySwitch()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 807
                self.assemblyFunctionDefinition()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 808
                self.assemblyFor()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 809
                self.assemblyIf()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 810
                self.match(SolidityParser.BreakKeyword)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 811
                self.match(SolidityParser.ContinueKeyword)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 812
                self.subAssembly()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 813
                self.numberLiteral()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 814
                self.match(SolidityParser.StringLiteral)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 815
                self.match(SolidityParser.HexLiteral)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyExpressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyCall(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyCallContext,0)


        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyExpression" ):
                listener.enterAssemblyExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyExpression" ):
                listener.exitAssemblyExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyExpression" ):
                return visitor.visitAssemblyExpression(self)
            else:
                return visitor.visitChildren(self)




    def assemblyExpression(self):

        localctx = SolidityParser.AssemblyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_assemblyExpression)
        try:
            self.state = 820
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__12, SolidityParser.T__33, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__51, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 818
                self.assemblyCall()
                pass
            elif token in [SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.StringLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 819
                self.assemblyLiteral()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyCallContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyCall" ):
                listener.enterAssemblyCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyCall" ):
                listener.exitAssemblyCall(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyCall" ):
                return visitor.visitAssemblyCall(self)
            else:
                return visitor.visitChildren(self)




    def assemblyCall(self):

        localctx = SolidityParser.AssemblyCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_assemblyCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 826
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__45]:
                self.state = 822
                self.match(SolidityParser.T__45)
                pass
            elif token in [SolidityParser.T__33]:
                self.state = 823
                self.match(SolidityParser.T__33)
                pass
            elif token in [SolidityParser.T__51]:
                self.state = 824
                self.match(SolidityParser.T__51)
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.Identifier]:
                self.state = 825
                self.identifier()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 840
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 828
                self.match(SolidityParser.T__20)
                self.state = 830
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__51))) != 0) or ((((_la - 98)) & ~0x3f) == 0 and ((1 << (_la - 98)) & ((1 << (SolidityParser.DecimalNumber - 98)) | (1 << (SolidityParser.HexNumber - 98)) | (1 << (SolidityParser.HexLiteral - 98)) | (1 << (SolidityParser.Identifier - 98)) | (1 << (SolidityParser.StringLiteral - 98)))) != 0):
                    self.state = 829
                    self.assemblyExpression()


                self.state = 836
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 832
                    self.match(SolidityParser.T__14)
                    self.state = 833
                    self.assemblyExpression()
                    self.state = 838
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 839
                self.match(SolidityParser.T__21)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyLocalDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLocalDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyLocalDefinition" ):
                listener.enterAssemblyLocalDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyLocalDefinition" ):
                listener.exitAssemblyLocalDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyLocalDefinition" ):
                return visitor.visitAssemblyLocalDefinition(self)
            else:
                return visitor.visitChildren(self)




    def assemblyLocalDefinition(self):

        localctx = SolidityParser.AssemblyLocalDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_assemblyLocalDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 842
            self.match(SolidityParser.T__83)
            self.state = 843
            self.assemblyIdentifierOrList()
            self.state = 846
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__84:
                self.state = 844
                self.match(SolidityParser.T__84)
                self.state = 845
                self.assemblyExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyAssignmentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyAssignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyAssignment" ):
                listener.enterAssemblyAssignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyAssignment" ):
                listener.exitAssemblyAssignment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyAssignment" ):
                return visitor.visitAssemblyAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assemblyAssignment(self):

        localctx = SolidityParser.AssemblyAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_assemblyAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 848
            self.assemblyIdentifierOrList()
            self.state = 849
            self.match(SolidityParser.T__84)
            self.state = 850
            self.assemblyExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIdentifierOrListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierOrList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyIdentifierOrList" ):
                listener.enterAssemblyIdentifierOrList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyIdentifierOrList" ):
                listener.exitAssemblyIdentifierOrList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIdentifierOrList" ):
                return visitor.visitAssemblyIdentifierOrList(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIdentifierOrList(self):

        localctx = SolidityParser.AssemblyIdentifierOrListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_assemblyIdentifierOrList)
        try:
            self.state = 857
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 852
                self.identifier()
                pass
            elif token in [SolidityParser.T__20]:
                self.enterOuterAlt(localctx, 2)
                self.state = 853
                self.match(SolidityParser.T__20)
                self.state = 854
                self.assemblyIdentifierList()
                self.state = 855
                self.match(SolidityParser.T__21)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIdentifierListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyIdentifierList" ):
                listener.enterAssemblyIdentifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyIdentifierList" ):
                listener.exitAssemblyIdentifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIdentifierList" ):
                return visitor.visitAssemblyIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIdentifierList(self):

        localctx = SolidityParser.AssemblyIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_assemblyIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 859
            self.identifier()
            self.state = 864
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 860
                self.match(SolidityParser.T__14)
                self.state = 861
                self.identifier()
                self.state = 866
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyStackAssignmentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyStackAssignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyStackAssignment" ):
                listener.enterAssemblyStackAssignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyStackAssignment" ):
                listener.exitAssemblyStackAssignment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyStackAssignment" ):
                return visitor.visitAssemblyStackAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assemblyStackAssignment(self):

        localctx = SolidityParser.AssemblyStackAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_assemblyStackAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 867
            self.match(SolidityParser.T__85)
            self.state = 868
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabelDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_labelDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLabelDefinition" ):
                listener.enterLabelDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLabelDefinition" ):
                listener.exitLabelDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLabelDefinition" ):
                return visitor.visitLabelDefinition(self)
            else:
                return visitor.visitChildren(self)




    def labelDefinition(self):

        localctx = SolidityParser.LabelDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_labelDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 870
            self.identifier()
            self.state = 871
            self.match(SolidityParser.T__72)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblySwitchContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyCase(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyCaseContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyCaseContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblySwitch

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblySwitch" ):
                listener.enterAssemblySwitch(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblySwitch" ):
                listener.exitAssemblySwitch(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblySwitch" ):
                return visitor.visitAssemblySwitch(self)
            else:
                return visitor.visitChildren(self)




    def assemblySwitch(self):

        localctx = SolidityParser.AssemblySwitchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_assemblySwitch)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 873
            self.match(SolidityParser.T__86)
            self.state = 874
            self.assemblyExpression()
            self.state = 878
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__87 or _la==SolidityParser.T__88:
                self.state = 875
                self.assemblyCase()
                self.state = 880
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyCaseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCase

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyCase" ):
                listener.enterAssemblyCase(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyCase" ):
                listener.exitAssemblyCase(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyCase" ):
                return visitor.visitAssemblyCase(self)
            else:
                return visitor.visitChildren(self)




    def assemblyCase(self):

        localctx = SolidityParser.AssemblyCaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_assemblyCase)
        try:
            self.state = 887
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__87]:
                self.enterOuterAlt(localctx, 1)
                self.state = 881
                self.match(SolidityParser.T__87)
                self.state = 882
                self.assemblyLiteral()
                self.state = 883
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__88]:
                self.enterOuterAlt(localctx, 2)
                self.state = 885
                self.match(SolidityParser.T__88)
                self.state = 886
                self.assemblyBlock()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyFunctionDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def assemblyFunctionReturns(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionReturnsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyFunctionDefinition" ):
                listener.enterAssemblyFunctionDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyFunctionDefinition" ):
                listener.exitAssemblyFunctionDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFunctionDefinition" ):
                return visitor.visitAssemblyFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFunctionDefinition(self):

        localctx = SolidityParser.AssemblyFunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_assemblyFunctionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 889
            self.match(SolidityParser.T__27)
            self.state = 890
            self.identifier()
            self.state = 891
            self.match(SolidityParser.T__20)
            self.state = 893
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier:
                self.state = 892
                self.assemblyIdentifierList()


            self.state = 895
            self.match(SolidityParser.T__21)
            self.state = 897
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__89:
                self.state = 896
                self.assemblyFunctionReturns()


            self.state = 899
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyFunctionReturnsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionReturns

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyFunctionReturns" ):
                listener.enterAssemblyFunctionReturns(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyFunctionReturns" ):
                listener.exitAssemblyFunctionReturns(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFunctionReturns" ):
                return visitor.visitAssemblyFunctionReturns(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFunctionReturns(self):

        localctx = SolidityParser.AssemblyFunctionReturnsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_assemblyFunctionReturns)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 901
            self.match(SolidityParser.T__89)
            self.state = 902
            self.assemblyIdentifierList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyForContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def assemblyBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyBlockContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFor

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyFor" ):
                listener.enterAssemblyFor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyFor" ):
                listener.exitAssemblyFor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFor" ):
                return visitor.visitAssemblyFor(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFor(self):

        localctx = SolidityParser.AssemblyForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_assemblyFor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 904
            self.match(SolidityParser.T__23)
            self.state = 907
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__13]:
                self.state = 905
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__33, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__51, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 906
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 909
            self.assemblyExpression()
            self.state = 912
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__13]:
                self.state = 910
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__33, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__51, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 911
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 914
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIfContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIf

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyIf" ):
                listener.enterAssemblyIf(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyIf" ):
                listener.exitAssemblyIf(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIf" ):
                return visitor.visitAssemblyIf(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIf(self):

        localctx = SolidityParser.AssemblyIfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_assemblyIf)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 916
            self.match(SolidityParser.T__40)
            self.state = 917
            self.assemblyExpression()
            self.state = 918
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyLiteralContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def HexLiteral(self):
            return self.getToken(SolidityParser.HexLiteral, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssemblyLiteral" ):
                listener.enterAssemblyLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssemblyLiteral" ):
                listener.exitAssemblyLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyLiteral" ):
                return visitor.visitAssemblyLiteral(self)
            else:
                return visitor.visitChildren(self)




    def assemblyLiteral(self):

        localctx = SolidityParser.AssemblyLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_assemblyLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 920
            _la = self._input.LA(1)
            if not(((((_la - 98)) & ~0x3f) == 0 and ((1 << (_la - 98)) & ((1 << (SolidityParser.DecimalNumber - 98)) | (1 << (SolidityParser.HexNumber - 98)) | (1 << (SolidityParser.HexLiteral - 98)) | (1 << (SolidityParser.StringLiteral - 98)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubAssemblyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_subAssembly

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubAssembly" ):
                listener.enterSubAssembly(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubAssembly" ):
                listener.exitSubAssembly(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubAssembly" ):
                return visitor.visitSubAssembly(self)
            else:
                return visitor.visitChildren(self)




    def subAssembly(self):

        localctx = SolidityParser.SubAssemblyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_subAssembly)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 922
            self.match(SolidityParser.T__43)
            self.state = 923
            self.identifier()
            self.state = 924
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TupleExpressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_tupleExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTupleExpression" ):
                listener.enterTupleExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTupleExpression" ):
                listener.exitTupleExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTupleExpression" ):
                return visitor.visitTupleExpression(self)
            else:
                return visitor.visitChildren(self)




    def tupleExpression(self):

        localctx = SolidityParser.TupleExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_tupleExpression)
        self._la = 0 # Token type
        try:
            self.state = 952
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__20]:
                self.enterOuterAlt(localctx, 1)
                self.state = 926
                self.match(SolidityParser.T__20)

                self.state = 928
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                    self.state = 927
                    self.expression(0)


                self.state = 936
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 930
                    self.match(SolidityParser.T__14)
                    self.state = 932
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                        self.state = 931
                        self.expression(0)


                    self.state = 938
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 939
                self.match(SolidityParser.T__21)
                pass
            elif token in [SolidityParser.T__31]:
                self.enterOuterAlt(localctx, 2)
                self.state = 940
                self.match(SolidityParser.T__31)
                self.state = 949
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59))) != 0) or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & ((1 << (SolidityParser.Int - 91)) | (1 << (SolidityParser.Uint - 91)) | (1 << (SolidityParser.Byte - 91)) | (1 << (SolidityParser.Fixed - 91)) | (1 << (SolidityParser.Ufixed - 91)) | (1 << (SolidityParser.BooleanLiteral - 91)) | (1 << (SolidityParser.DecimalNumber - 91)) | (1 << (SolidityParser.HexNumber - 91)) | (1 << (SolidityParser.HexLiteral - 91)) | (1 << (SolidityParser.Identifier - 91)) | (1 << (SolidityParser.StringLiteral - 91)))) != 0):
                    self.state = 941
                    self.expression(0)
                    self.state = 946
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SolidityParser.T__14:
                        self.state = 942
                        self.match(SolidityParser.T__14)
                        self.state = 943
                        self.expression(0)
                        self.state = 948
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 951
                self.match(SolidityParser.T__32)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElementaryTypeNameExpressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_elementaryTypeNameExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElementaryTypeNameExpression" ):
                listener.enterElementaryTypeNameExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElementaryTypeNameExpression" ):
                listener.exitElementaryTypeNameExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElementaryTypeNameExpression" ):
                return visitor.visitElementaryTypeNameExpression(self)
            else:
                return visitor.visitChildren(self)




    def elementaryTypeNameExpression(self):

        localctx = SolidityParser.ElementaryTypeNameExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_elementaryTypeNameExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 954
            self.elementaryTypeName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberLiteralContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def NumberUnit(self):
            return self.getToken(SolidityParser.NumberUnit, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_numberLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumberLiteral" ):
                listener.enterNumberLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumberLiteral" ):
                listener.exitNumberLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumberLiteral" ):
                return visitor.visitNumberLiteral(self)
            else:
                return visitor.visitChildren(self)




    def numberLiteral(self):

        localctx = SolidityParser.NumberLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_numberLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 956
            _la = self._input.LA(1)
            if not(_la==SolidityParser.DecimalNumber or _la==SolidityParser.HexNumber):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 958
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
            if la_ == 1:
                self.state = 957
                self.match(SolidityParser.NumberUnit)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(SolidityParser.Identifier, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_identifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdentifier" ):
                listener.enterIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdentifier" ):
                listener.exitIdentifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifier" ):
                return visitor.visitIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def identifier(self):

        localctx = SolidityParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 960
            _la = self._input.LA(1)
            if not(_la==SolidityParser.T__12 or _la==SolidityParser.T__39 or _la==SolidityParser.Identifier):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[31] = self.typeName_sempred
        self._predicates[55] = self.expression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def typeName_sempred(self, localctx:TypeNameContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 3)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 14)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 13)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 12)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 14:
                return self.precpred(self._ctx, 25)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 23)
         

            if predIndex == 16:
                return self.precpred(self._ctx, 22)
         

            if predIndex == 17:
                return self.precpred(self._ctx, 21)
         




